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

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

@@ -12,6 +12,7 @@ import { type Connect } from "vite";
  */
 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, handlerOptions
     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,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,MAAM,CAAC;AAIpC;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqMhB"}
+{"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"}

package/dist/plugin/helpers/requestInfo.js

@@ -7,6 +7,7 @@ import { resolve } from 'node:path';
 import 'vite';
 import { MIME_TYPES } from '../config/mimeTypes.js';
 import { requestToRoute } from './requestToRoute.js';
+import { routeToURL } from '../utils/routeToURL.js';
 
 function requestInfo(req, handlerOptions, hostDir) {
   const route = requestToRoute(req, {
@@ -17,6 +18,7 @@ function requestInfo(req, handlerOptions, hostDir) {
   if (!route) {
     return {
       route: "/",
+      url: routeToURL("/", handlerOptions.moduleBaseURL, handlerOptions.build.rscOutputPath),
       ext: ""
     };
   }
@@ -50,7 +52,8 @@ function requestInfo(req, handlerOptions, hostDir) {
   const isFormContentType = req.headers["content-type"]?.includes(
     "application/x-www-form-urlencoded"
   ) || !!req.headers["content-type"]?.includes("multipart/form-data");
-  const hasServerActionHeaders = req.method === "POST" && (req.headers["sec-fetch-dest"] === "empty" || req.headers["sec-fetch-dest"] === "") && req.headers["sec-fetch-mode"] === "cors";
+  const hasRscActionHeader = !!req.headers["x-rsc-action"];
+  const hasServerActionHeaders = req.method === "POST" && (hasRscActionHeader || (req.headers["sec-fetch-dest"] === "empty" || req.headers["sec-fetch-dest"] === "") && req.headers["sec-fetch-mode"] === "cors");
   const isServerActionRequest = hasServerActionHeaders;
   const isFormActionRequest = !isServerActionRequest && (req.method === "POST" || isFormContentType && req.headers["sec-fetch-dest"] === "document" && req.headers["sec-fetch-mode"] === "navigate");
   const isJsRequest = !isFormActionRequest && !isJson && !isHtml && !isCss && !isRsc && (isJS || hasJsHeader);
@@ -126,6 +129,7 @@ function requestInfo(req, handlerOptions, hostDir) {
   }
   return {
     route,
+    url: routeToURL(route, handlerOptions.moduleBaseURL, handlerOptions.build.rscOutputPath),
     ext,
     isHtmlRequest,
     isRscRequest,
@@ -155,4 +159,4 @@ function requestInfo(req, handlerOptions, hostDir) {
 }
 
 export { requestInfo };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"requestInfo.js","sources":["../../../plugin/helpers/requestInfo.ts"],"sourcesContent":["import { resolve } from \"node:path\";\nimport type { CreateHandlerOptions } from \"../types.js\";\nimport { type Connect } from \"vite\";\nimport { MIME_TYPES } from \"../config/mimeTypes.js\";\nimport { requestToRoute } from \"./requestToRoute.js\";\n\n/**\n * # Request info\n *\n * 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.\n *\n * @param req\n * @param handlerOptions\n * @param hostDir\n * @returns\n */\nexport function requestInfo(\n  req: Connect.IncomingMessage,\n  handlerOptions: Pick<\n    CreateHandlerOptions,\n    | \"normalizer\"\n    | \"build\"\n    | \"autoDiscover\"\n    | \"verbose\"\n    | \"moduleBasePath\"\n    | \"moduleBaseURL\"\n    | \"verbose\"\n    | \"logger\"\n  >,\n  hostDir: string,\n) {\n  const route = requestToRoute(req, {\n    moduleBasePath: handlerOptions.moduleBasePath,\n    moduleBaseURL: handlerOptions.moduleBaseURL,\n    build: handlerOptions.build,\n  });\n\n  if (!route) {\n    return {\n      route: \"/\",\n      ext: \"\",\n    };\n  }\n\n  // Use the cleaned route for normalization, not the raw req.url\n  // This ensures base URL is properly stripped before normalization\n  const [, value] = handlerOptions.normalizer(route);\n  if (handlerOptions.verbose) {\n    if (value && value !== \"\") {\n      handlerOptions.logger.info(`[requestInfo] Value: \\\"${value}\\\"`);\n    }\n    if (hostDir && hostDir !== \"\") {\n      handlerOptions.logger.info(`[requestInfo] Host Dir: \\\"${hostDir}\\\"`);\n    }\n    if (req.url && req.url !== \"\") {\n      handlerOptions.logger.info(`[requestInfo] Request URL: \\\"${req.url}\\\"`);\n    }\n  }\n\n  const dotIndex = value.lastIndexOf(\".\");\n  const ext = dotIndex === -1 ? \"\" : value.slice(dotIndex);\n  // handle index.html\n  const isVendor = handlerOptions.autoDiscover.vendorPattern.test(value);\n  const isVirtual = handlerOptions.autoDiscover.virtualPattern.test(value);\n  const isJS = handlerOptions.autoDiscover.modulePattern.test(value);\n  const isHtml = handlerOptions.autoDiscover.htmlPattern.test(value);\n  const isCss = handlerOptions.autoDiscover.cssPattern.test(value);\n  const isJson = handlerOptions.autoDiscover.jsonPattern.test(value);\n  const isRsc = handlerOptions.autoDiscover.rscPattern.test(value);\n  const hasJsHeader =\n    req.headers[\"sec-fetch-dest\"] === \"script\" ||\n    req.headers[\"accept\"]?.includes(\"*/*\") ||\n    req.headers[\"accept\"]?.includes(\"text/javascript\");\n  const hasJsonHeader = req.headers[\"accept\"]?.includes(\"application/json\");\n  const hasHtmlHeader = req.headers.accept?.includes(\"text/html\");\n  const hasRscHeader = req.headers.accept?.includes(\"text/x-component\");\n  const hasCssHeader = req.headers.accept?.includes(\"text/css\");\n  const isFolder = !ext;\n  const isFormContentType =\n    req.headers[\"content-type\"]?.includes(\n      \"application/x-www-form-urlencoded\"\n    ) || !!req.headers[\"content-type\"]?.includes(\"multipart/form-data\");\n\n  // Server action detection\n  const hasServerActionHeaders =\n    req.method === \"POST\" &&\n    (req.headers[\"sec-fetch-dest\"] === \"empty\" ||\n      req.headers[\"sec-fetch-dest\"] === \"\") &&\n    req.headers[\"sec-fetch-mode\"] === \"cors\";\n  const isServerActionRequest = hasServerActionHeaders;\n\n  const isFormActionRequest =\n    !isServerActionRequest &&\n    (req.method === \"POST\" ||\n      (isFormContentType &&\n        req.headers[\"sec-fetch-dest\"] === \"document\" &&\n        req.headers[\"sec-fetch-mode\"] === \"navigate\"));\n\n  const isJsRequest =\n    !isFormActionRequest &&\n    !isJson &&\n    !isHtml &&\n    !isCss &&\n    !isRsc &&\n    (isJS || hasJsHeader);\n  const isJsonRequest = isJson || (hasJsonHeader && !isJsRequest);\n  // Form action detection\n\n  const isHtmlRequest =\n    isHtml ||\n    hasHtmlHeader ||\n    (isFolder &&\n      !hasRscHeader &&\n      !isRsc &&\n      !isJsRequest &&\n      !isFormActionRequest);\n  const isRscRequest =\n    !isJsRequest && !isHtmlRequest && (isRsc || hasRscHeader);\n  const isCssRequest =\n    !isHtmlRequest &&\n    !isRscRequest &&\n    !isJsRequest &&\n    !isJsonRequest &&\n    (isCss || hasCssHeader);\n\n  // Use the normalized value for file path construction\n  // The normalizer should have already stripped base URLs properly\n  const routeForFilePath = value;\n\n  let filePath = resolve(hostDir, routeForFilePath);\n  let contentType;\n  if (isServerActionRequest) {\n    // For server actions, we'll get the actual file path from the request body\n    // The route is just a placeholder\n    filePath = resolve(hostDir, routeForFilePath);\n    contentType = \"application/json; charset=utf-8\";\n  } else if (isHtmlRequest) {\n    if (!isHtml) {\n      filePath = resolve(\n        hostDir,\n        routeForFilePath,\n        handlerOptions.build.htmlOutputPath\n      );\n    }\n    contentType = \"text/html; charset=utf-8\";\n  } else if (isRscRequest) {\n    if (!isRsc) {\n      // Value doesn't end with .rsc, append the rsc output path\n      filePath = resolve(\n        hostDir,\n        routeForFilePath,\n        handlerOptions.build.rscOutputPath\n      );\n    }\n    contentType = \"text/x-component; charset=utf-8\";\n  } else if (isCssRequest) {\n    if (!isCss) {\n      filePath = resolve(hostDir, routeForFilePath + \".css\");\n    }\n    contentType = \"text/css; charset=utf-8\";\n  } else if (isJsRequest) {\n    if (!isJS) {\n      filePath = resolve(hostDir, routeForFilePath + \".js\");\n    }\n    contentType = \"application/javascript; charset=utf-8\";\n  } else if (isJsonRequest) {\n    if (!isJson) {\n      filePath = resolve(hostDir, routeForFilePath + \".json\");\n    }\n    contentType = \"application/json; charset=utf-8\";\n  } else {\n    const mimeType = MIME_TYPES[ext];\n    if (mimeType) {\n      contentType = mimeType + \"; charset=utf-8\";\n    } else {\n      contentType = \"application/octet-stream; charset=utf-8\";\n    }\n  }\n\n  if (handlerOptions.verbose) {\n    if (isFormActionRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (form-action) ${route}`);\n    } else if (isServerActionRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (server-action) ${route}`);\n    } else if (isHtmlRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (html) ${route}`);\n    } else if (isRscRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (rsc) ${route}`);\n    } else if (isCssRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (css) ${route}`);\n    } else if (isJsRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (js) ${route}`);\n    } else if (isJsonRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (json) ${route}`);\n    } else {\n      handlerOptions.logger.info(`[react-dev-server] (other) ${route}`);\n    }\n  }\n  return {\n    route,\n    ext,\n    isHtmlRequest,\n    isRscRequest,\n    isCssRequest,\n    isCss,\n    isHtml,\n    isRsc,\n    isFolder,\n    contentType,\n    filePath,\n    isJS,\n    isVendor,\n    isVirtual,\n    hasJsHeader,\n    isJsRequest,\n    isJson,\n    isJsonRequest,\n    hasCssHeader,\n    hasJsonHeader,\n    hasHtmlHeader,\n    hasRscHeader,\n    hasServerActionHeaders,\n    isServerActionRequest,\n    isFormContentType,\n    isFormActionRequest,\n  };\n}\n"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"requestInfo.js","sources":["../../../plugin/helpers/requestInfo.ts"],"sourcesContent":["import { resolve } from \"node:path\";\nimport type { CreateHandlerOptions } from \"../types.js\";\nimport { type Connect } from \"vite\";\nimport { MIME_TYPES } from \"../config/mimeTypes.js\";\nimport { requestToRoute } from \"./requestToRoute.js\";\nimport { routeToURL } from \"../utils/routeToURL.js\";\n\n/**\n * # Request info\n *\n * 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.\n *\n * @param req\n * @param handlerOptions\n * @param hostDir\n * @returns\n */\nexport function requestInfo(\n  req: Connect.IncomingMessage,\n  handlerOptions: Pick<\n    CreateHandlerOptions,\n    | \"normalizer\"\n    | \"build\"\n    | \"autoDiscover\"\n    | \"verbose\"\n    | \"moduleBasePath\"\n    | \"moduleBaseURL\"\n    | \"verbose\"\n    | \"logger\"\n  >,\n  hostDir: string,\n) {\n  const route = requestToRoute(req, {\n    moduleBasePath: handlerOptions.moduleBasePath,\n    moduleBaseURL: handlerOptions.moduleBaseURL,\n    build: handlerOptions.build,\n  });\n\n  if (!route) {\n    return {\n      route: \"/\",\n      url: routeToURL(\"/\", handlerOptions.moduleBaseURL, handlerOptions.build.rscOutputPath),\n      ext: \"\",\n    };\n  }\n\n  // Use the cleaned route for normalization, not the raw req.url\n  // This ensures base URL is properly stripped before normalization\n  const [, value] = handlerOptions.normalizer(route);\n  if (handlerOptions.verbose) {\n    if (value && value !== \"\") {\n      handlerOptions.logger.info(`[requestInfo] Value: \\\"${value}\\\"`);\n    }\n    if (hostDir && hostDir !== \"\") {\n      handlerOptions.logger.info(`[requestInfo] Host Dir: \\\"${hostDir}\\\"`);\n    }\n    if (req.url && req.url !== \"\") {\n      handlerOptions.logger.info(`[requestInfo] Request URL: \\\"${req.url}\\\"`);\n    }\n  }\n\n  const dotIndex = value.lastIndexOf(\".\");\n  const ext = dotIndex === -1 ? \"\" : value.slice(dotIndex);\n  // handle index.html\n  const isVendor = handlerOptions.autoDiscover.vendorPattern.test(value);\n  const isVirtual = handlerOptions.autoDiscover.virtualPattern.test(value);\n  const isJS = handlerOptions.autoDiscover.modulePattern.test(value);\n  const isHtml = handlerOptions.autoDiscover.htmlPattern.test(value);\n  const isCss = handlerOptions.autoDiscover.cssPattern.test(value);\n  const isJson = handlerOptions.autoDiscover.jsonPattern.test(value);\n  const isRsc = handlerOptions.autoDiscover.rscPattern.test(value);\n  const hasJsHeader =\n    req.headers[\"sec-fetch-dest\"] === \"script\" ||\n    req.headers[\"accept\"]?.includes(\"*/*\") ||\n    req.headers[\"accept\"]?.includes(\"text/javascript\");\n  const hasJsonHeader = req.headers[\"accept\"]?.includes(\"application/json\");\n  const hasHtmlHeader = req.headers.accept?.includes(\"text/html\");\n  const hasRscHeader = req.headers.accept?.includes(\"text/x-component\");\n  const hasCssHeader = req.headers.accept?.includes(\"text/css\");\n  const isFolder = !ext;\n  const isFormContentType =\n    req.headers[\"content-type\"]?.includes(\n      \"application/x-www-form-urlencoded\"\n    ) || !!req.headers[\"content-type\"]?.includes(\"multipart/form-data\");\n\n  // Server action detection\n  const hasRscActionHeader = !!req.headers[\"x-rsc-action\"];\n  const hasServerActionHeaders =\n    req.method === \"POST\" &&\n    (hasRscActionHeader || (\n      (req.headers[\"sec-fetch-dest\"] === \"empty\" ||\n        req.headers[\"sec-fetch-dest\"] === \"\") &&\n      req.headers[\"sec-fetch-mode\"] === \"cors\"\n    ));\n  const isServerActionRequest = hasServerActionHeaders;\n\n  const isFormActionRequest =\n    !isServerActionRequest &&\n    (req.method === \"POST\" ||\n      (isFormContentType &&\n        req.headers[\"sec-fetch-dest\"] === \"document\" &&\n        req.headers[\"sec-fetch-mode\"] === \"navigate\"));\n\n  const isJsRequest =\n    !isFormActionRequest &&\n    !isJson &&\n    !isHtml &&\n    !isCss &&\n    !isRsc &&\n    (isJS || hasJsHeader);\n  const isJsonRequest = isJson || (hasJsonHeader && !isJsRequest);\n  // Form action detection\n\n  const isHtmlRequest =\n    isHtml ||\n    hasHtmlHeader ||\n    (isFolder &&\n      !hasRscHeader &&\n      !isRsc &&\n      !isJsRequest &&\n      !isFormActionRequest);\n  const isRscRequest =\n    !isJsRequest && !isHtmlRequest && (isRsc || hasRscHeader);\n  const isCssRequest =\n    !isHtmlRequest &&\n    !isRscRequest &&\n    !isJsRequest &&\n    !isJsonRequest &&\n    (isCss || hasCssHeader);\n\n  // Use the normalized value for file path construction\n  // The normalizer should have already stripped base URLs properly\n  const routeForFilePath = value;\n\n  let filePath = resolve(hostDir, routeForFilePath);\n  let contentType;\n  if (isServerActionRequest) {\n    // For server actions, we'll get the actual file path from the request body\n    // The route is just a placeholder\n    filePath = resolve(hostDir, routeForFilePath);\n    contentType = \"application/json; charset=utf-8\";\n  } else if (isHtmlRequest) {\n    if (!isHtml) {\n      filePath = resolve(\n        hostDir,\n        routeForFilePath,\n        handlerOptions.build.htmlOutputPath\n      );\n    }\n    contentType = \"text/html; charset=utf-8\";\n  } else if (isRscRequest) {\n    if (!isRsc) {\n      // Value doesn't end with .rsc, append the rsc output path\n      filePath = resolve(\n        hostDir,\n        routeForFilePath,\n        handlerOptions.build.rscOutputPath\n      );\n    }\n    contentType = \"text/x-component; charset=utf-8\";\n  } else if (isCssRequest) {\n    if (!isCss) {\n      filePath = resolve(hostDir, routeForFilePath + \".css\");\n    }\n    contentType = \"text/css; charset=utf-8\";\n  } else if (isJsRequest) {\n    if (!isJS) {\n      filePath = resolve(hostDir, routeForFilePath + \".js\");\n    }\n    contentType = \"application/javascript; charset=utf-8\";\n  } else if (isJsonRequest) {\n    if (!isJson) {\n      filePath = resolve(hostDir, routeForFilePath + \".json\");\n    }\n    contentType = \"application/json; charset=utf-8\";\n  } else {\n    const mimeType = MIME_TYPES[ext];\n    if (mimeType) {\n      contentType = mimeType + \"; charset=utf-8\";\n    } else {\n      contentType = \"application/octet-stream; charset=utf-8\";\n    }\n  }\n\n  if (handlerOptions.verbose) {\n    if (isFormActionRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (form-action) ${route}`);\n    } else if (isServerActionRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (server-action) ${route}`);\n    } else if (isHtmlRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (html) ${route}`);\n    } else if (isRscRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (rsc) ${route}`);\n    } else if (isCssRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (css) ${route}`);\n    } else if (isJsRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (js) ${route}`);\n    } else if (isJsonRequest) {\n      handlerOptions.logger.info(`[react-dev-server] (json) ${route}`);\n    } else {\n      handlerOptions.logger.info(`[react-dev-server] (other) ${route}`);\n    }\n  }\n  return {\n    route,\n    url: routeToURL(route, handlerOptions.moduleBaseURL, handlerOptions.build.rscOutputPath),\n    ext,\n    isHtmlRequest,\n    isRscRequest,\n    isCssRequest,\n    isCss,\n    isHtml,\n    isRsc,\n    isFolder,\n    contentType,\n    filePath,\n    isJS,\n    isVendor,\n    isVirtual,\n    hasJsHeader,\n    isJsRequest,\n    isJson,\n    isJsonRequest,\n    hasCssHeader,\n    hasJsonHeader,\n    hasHtmlHeader,\n    hasRscHeader,\n    hasServerActionHeaders,\n    isServerActionRequest,\n    isFormContentType,\n    isFormActionRequest,\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/plugin/helpers/resolveComponents.client.d.ts

@@ -0,0 +1,34 @@
+import type { Worker } from "node:worker_threads";
+export interface ResolveComponentsOptions {
+    route: string;
+    pagePath?: string;
+    propsPath?: string;
+    rootPath?: string;
+    htmlPath?: string;
+    pageExportName?: string;
+    propsExportName?: string;
+    rootExportName?: string;
+    htmlExportName?: string;
+    worker?: Worker;
+    rscWorker?: Worker;
+    onMetrics?: (metrics: any) => void;
+    logger?: any;
+    verbose?: boolean;
+}
+export interface ResolvedComponents {
+    resolutionTime: number;
+}
+/**
+ * Resolves components using the RSC worker for client-side rendering
+ *
+ * This function:
+ * 1. Sends a RESOLVE_COMPONENTS message to the RSC worker
+ * 2. RSC worker resolves components using built paths from manifest
+ * 3. Returns resolved components with proper built paths
+ * 4. Tracks resolution metrics
+ *
+ * This separates component resolution from RSC generation, making the
+ * subsequent RSC render completely synchronous.
+ */
+export declare function resolveComponents(options: ResolveComponentsOptions): Promise<ResolvedComponents>;
+//# sourceMappingURL=resolveComponents.client.d.ts.map

package/dist/plugin/helpers/resolveComponents.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveComponents.client.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/resolveComponents.client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAQlD,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,IAAI,CAAC;IACnC,MAAM,CAAC,EAAE,GAAG,CAAC;IACb,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,kBAAkB;IACjC,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,kBAAkB,CAAC,CA2I7B"}