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

package/dist/plugin/helpers/resolveComponents.client.js

@@ -0,0 +1,126 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { createModuleResolutionMetrics } from '../metrics/createModuleResolutionMetrics.js';
+import { performance } from 'node:perf_hooks';
+
+async function resolveComponents(options) {
+  const {
+    route,
+    pagePath,
+    propsPath,
+    rootPath,
+    htmlPath,
+    pageExportName,
+    propsExportName,
+    rootExportName,
+    htmlExportName,
+    rscWorker,
+    worker: workerProp,
+    onMetrics,
+    logger,
+    verbose
+  } = options;
+  const worker = rscWorker ?? workerProp;
+  if (!worker) {
+    throw new Error(
+      "RSC Worker is required for client-side component resolution"
+    );
+  }
+  const resolutionStartTime = performance.now();
+  if (verbose) {
+    logger?.info(
+      `[resolveComponents.client] Resolving components for route: ${route}`
+    );
+    logger?.info(`[resolveComponents.client] pagePath: ${pagePath}`);
+    logger?.info(`[resolveComponents.client] propsPath: ${propsPath}`);
+    logger?.info(`[resolveComponents.client] rootPath: ${rootPath}`);
+    logger?.info(`[resolveComponents.client] htmlPath: ${htmlPath}`);
+  }
+  const resolveMessage = {
+    type: "RESOLVE_COMPONENTS",
+    id: `${route}-resolve-${Date.now()}`,
+    route,
+    streamType: "rsc",
+    rscVariant: "rsc-full",
+    // We'll determine this based on htmlPath later
+    pagePath,
+    propsPath,
+    rootPath,
+    htmlPath,
+    pageExportName,
+    propsExportName,
+    rootExportName,
+    htmlExportName
+  };
+  try {
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error(`Component resolution timeout for route: ${route}`));
+      }, 3e3);
+      const messageHandler = (message) => {
+        if (message.type === "COMPONENTS_RESOLVED" && message.id === resolveMessage.id) {
+          clearTimeout(timeout);
+          worker.off("message", messageHandler);
+          resolve(message);
+        } else if (message.type === "ERROR" && message.id === resolveMessage.id) {
+          clearTimeout(timeout);
+          worker.off("message", messageHandler);
+          reject(
+            new Error(
+              `Component resolution failed: ${message.error?.message || "Unknown error"}`
+            )
+          );
+        }
+      };
+      worker.on("message", messageHandler);
+      worker.postMessage(resolveMessage);
+    });
+    const resolutionTime = performance.now() - resolutionStartTime;
+    if (verbose) {
+      logger?.info(
+        `[resolveComponents.client] Components resolved for route: ${route} in ${resolutionTime.toFixed(
+          2
+        )}ms`
+      );
+    }
+    if (onMetrics) {
+      const moduleResolutionMetric = createModuleResolutionMetrics({
+        route,
+        workerType: "rsc",
+        resolutionTime,
+        fromMainThread: false,
+        fromRscWorker: true,
+        fromHtmlWorker: false,
+        description: `Component resolution for route ${route} on RSC worker`
+      });
+      onMetrics(moduleResolutionMetric);
+    }
+    return {
+      resolutionTime
+    };
+  } catch (error) {
+    const resolutionTime = performance.now() - resolutionStartTime;
+    logger?.error(
+      `[resolveComponents.client] Failed to resolve components for route ${route}: ${error}`
+    );
+    if (onMetrics) {
+      const moduleResolutionMetric = createModuleResolutionMetrics({
+        route,
+        workerType: "rsc",
+        resolutionTime,
+        fromMainThread: false,
+        fromRscWorker: true,
+        fromHtmlWorker: false,
+        description: `Component resolution failed for route ${route} on RSC worker`
+      });
+      onMetrics(moduleResolutionMetric);
+    }
+    throw error;
+  }
+}
+
+export { resolveComponents };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"resolveComponents.client.js","sources":["../../../plugin/helpers/resolveComponents.client.ts"],"sourcesContent":["import type { Worker } from \"node:worker_threads\";\nimport type {\n  ResolveComponentsMessage,\n  ComponentsResolvedMessage,\n} from \"../worker/rsc/types.js\";\nimport { createModuleResolutionMetrics } from \"../metrics/createModuleResolutionMetrics.js\";\nimport { performance } from \"node:perf_hooks\";\n\nexport interface ResolveComponentsOptions {\n  route: string;\n  pagePath?: string;\n  propsPath?: string;\n  rootPath?: string;\n  htmlPath?: string;\n  pageExportName?: string;\n  propsExportName?: string;\n  rootExportName?: string;\n  htmlExportName?: string;\n  worker?: Worker;\n  rscWorker?: Worker;\n  onMetrics?: (metrics: any) => void;\n  logger?: any;\n  verbose?: boolean;\n}\n\nexport interface ResolvedComponents {\n  resolutionTime: number;\n}\n\n/**\n * Resolves components using the RSC worker for client-side rendering\n *\n * This function:\n * 1. Sends a RESOLVE_COMPONENTS message to the RSC worker\n * 2. RSC worker resolves components using built paths from manifest\n * 3. Returns resolved components with proper built paths\n * 4. Tracks resolution metrics\n *\n * This separates component resolution from RSC generation, making the\n * subsequent RSC render completely synchronous.\n */\nexport async function resolveComponents(\n  options: ResolveComponentsOptions\n): Promise<ResolvedComponents> {\n  const {\n    route,\n    pagePath,\n    propsPath,\n    rootPath,\n    htmlPath,\n    pageExportName,\n    propsExportName,\n    rootExportName,\n    htmlExportName,\n    rscWorker,\n    worker: workerProp,\n    onMetrics,\n    logger,\n    verbose,\n  } = options;\n\n  const worker = rscWorker ?? workerProp;\n\n  if (!worker) {\n    throw new Error(\n      \"RSC Worker is required for client-side component resolution\"\n    );\n  }\n\n  const resolutionStartTime = performance.now();\n\n  if (verbose) {\n    logger?.info(\n      `[resolveComponents.client] Resolving components for route: ${route}`\n    );\n    logger?.info(`[resolveComponents.client] pagePath: ${pagePath}`);\n    logger?.info(`[resolveComponents.client] propsPath: ${propsPath}`);\n    logger?.info(`[resolveComponents.client] rootPath: ${rootPath}`);\n    logger?.info(`[resolveComponents.client] htmlPath: ${htmlPath}`);\n  }\n\n  // Send RESOLVE_COMPONENTS message to RSC worker\n  const resolveMessage: ResolveComponentsMessage = {\n    type: \"RESOLVE_COMPONENTS\",\n    id: `${route}-resolve-${Date.now()}`,\n    route,\n    streamType: \"rsc\",\n    rscVariant: \"rsc-full\", // We'll determine this based on htmlPath later\n    pagePath,\n    propsPath,\n    rootPath,\n    htmlPath,\n    pageExportName,\n    propsExportName,\n    rootExportName,\n    htmlExportName,\n  };\n\n  try {\n    // Send message to worker and wait for response\n    await new Promise<ComponentsResolvedMessage>((resolve, reject) => {\n      const timeout = setTimeout(() => {\n        reject(new Error(`Component resolution timeout for route: ${route}`));\n      }, 3000); // 3 second timeout\n\n      const messageHandler = (message: any) => {\n        if (\n          message.type === \"COMPONENTS_RESOLVED\" &&\n          message.id === resolveMessage.id\n        ) {\n          clearTimeout(timeout);\n          worker.off(\"message\", messageHandler);\n          resolve(message);\n        } else if (\n          message.type === \"ERROR\" &&\n          message.id === resolveMessage.id\n        ) {\n          clearTimeout(timeout);\n          worker.off(\"message\", messageHandler);\n          reject(\n            new Error(\n              `Component resolution failed: ${\n                message.error?.message || \"Unknown error\"\n              }`\n            )\n          );\n        }\n      };\n\n      worker.on(\"message\", messageHandler);\n      worker.postMessage(resolveMessage);\n    });\n\n    const resolutionTime = performance.now() - resolutionStartTime;\n\n    if (verbose) {\n      logger?.info(\n        `[resolveComponents.client] Components resolved for route: ${route} in ${resolutionTime.toFixed(\n          2\n        )}ms`\n      );\n    }\n\n    // Emit resolution metrics\n    if (onMetrics) {\n      const moduleResolutionMetric = createModuleResolutionMetrics({\n        route,\n        workerType: \"rsc\",\n        resolutionTime,\n        fromMainThread: false,\n        fromRscWorker: true,\n        fromHtmlWorker: false,\n        description: `Component resolution for route ${route} on RSC worker`,\n      });\n      onMetrics(moduleResolutionMetric);\n    }\n\n    return {\n      resolutionTime,\n    };\n  } catch (error) {\n    const resolutionTime = performance.now() - resolutionStartTime;\n    logger?.error(\n      `[resolveComponents.client] Failed to resolve components for route ${route}: ${error}`\n    );\n\n    // Emit error metrics\n    if (onMetrics) {\n      const moduleResolutionMetric = createModuleResolutionMetrics({\n        route,\n        workerType: \"rsc\",\n        resolutionTime,\n        fromMainThread: false,\n        fromRscWorker: true,\n        fromHtmlWorker: false,\n        description: `Component resolution failed for route ${route} on RSC worker`,\n      });\n      onMetrics(moduleResolutionMetric);\n    }\n\n    throw error;\n  }\n}\n"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,36 @@
+import type { Logger } from "vite";
+import type { InputNormalizer } from "../types.js";
+/**
+ * Shared utility for resolving module paths from manifests.
+ *
+ * This handles the common pattern of:
+ * 1. Normalizing the moduleId using the normalizer (if provided)
+ * 2. Looking up a source path in a manifest to get the built file path
+ * 3. Handling different manifest key formats (with/without moduleBase prefix)
+ * 4. Resolving the full file path for loading
+ *
+ * Used by both:
+ * - RSC worker loader (createRscWorkerLoader)
+ * - Build loader (createBuildLoader.server)
+ */
+export declare function resolveModuleFromManifest({ moduleId, normalizer, manifest, moduleBase, preserveModulesRoot, projectRoot, buildOutDir, buildServerDir, verbose, logger, }: {
+    moduleId: string;
+    normalizer?: InputNormalizer;
+    manifest: Record<string, {
+        file: string;
+    } | undefined>;
+    moduleBase: string;
+    preserveModulesRoot?: boolean;
+    projectRoot: string;
+    buildOutDir: string;
+    buildServerDir: string;
+    verbose?: boolean;
+    logger?: Logger;
+}): {
+    manifestEntry: {
+        file: string;
+    } | undefined;
+    resolvedPath: string | null;
+    builtModuleId: string;
+};
+//# sourceMappingURL=resolveModuleFromManifest.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolveModuleFromManifest.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/resolveModuleFromManifest.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAC;AACnC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,QAAQ,EACR,UAAU,EACV,QAAQ,EACR,UAAU,EACV,mBAAmB,EACnB,WAAW,EACX,WAAW,EACX,cAAc,EACd,OAAe,EACf,MAAM,GACP,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,eAAe,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC,CAAC;IACvD,UAAU,EAAE,MAAM,CAAC;IACnB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG;IACF,aAAa,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAC;IAC5C,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,aAAa,EAAE,MAAM,CAAC;CACvB,CAsDA"}

package/dist/plugin/helpers/resolveModuleFromManifest.js

@@ -0,0 +1,60 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { resolve } from 'node:path';
+
+function resolveModuleFromManifest({
+  moduleId,
+  normalizer,
+  manifest,
+  moduleBase,
+  preserveModulesRoot,
+  projectRoot,
+  buildOutDir,
+  buildServerDir,
+  verbose = false,
+  logger
+}) {
+  let normalizedKey = moduleId;
+  let normalizedValue = moduleId;
+  if (normalizer) {
+    [normalizedKey, normalizedValue] = normalizer(moduleId);
+  }
+  let manifestEntry = manifest[normalizedValue] ?? manifest[normalizedKey];
+  if (!manifestEntry && preserveModulesRoot === false && normalizedValue.startsWith(moduleBase + "/")) {
+    const withoutModuleBase = normalizedValue.replace(
+      moduleBase + "/",
+      ""
+    );
+    manifestEntry = manifest[withoutModuleBase];
+    if (verbose && manifestEntry) {
+      logger?.info(
+        `[resolveModuleFromManifest] Found entry after removing moduleBase: ${withoutModuleBase} -> ${manifestEntry.file}`
+      );
+    }
+  }
+  let builtModuleId = moduleId;
+  if (manifestEntry && manifestEntry.file) {
+    builtModuleId = manifestEntry.file;
+    if (verbose) {
+      logger?.info(
+        `[resolveModuleFromManifest] Resolved ${moduleId} -> ${builtModuleId} via manifest`
+      );
+    }
+  } else if (verbose) {
+    logger?.warn(
+      `[resolveModuleFromManifest] No manifest entry found for ${moduleId} (tried keys: ${normalizedValue}, ${normalizedKey}), using moduleId directly`
+    );
+  }
+  const resolvedPath = manifestEntry ? resolve(projectRoot, buildOutDir, buildServerDir, manifestEntry.file) : null;
+  return {
+    manifestEntry,
+    resolvedPath,
+    builtModuleId
+  };
+}
+
+export { resolveModuleFromManifest };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

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

@@ -1,4 +1,11 @@
 import type { CreateHandlerOptions, PageComponentType, PagePropOpt } from "../types.js";
+/**
+ * Resolves the page and props for a given route, works in combination with resolveComponents
+ * The special thing it does is that if the props is already in the page module, it will fallback to that.
+ * @param handlerOptions - The handler options.
+ * @returns The resolved page and props.
+ */
+export declare const resolvePageAndProps: ResolvePageAndPropsFn;
 type ResolvePageAndPropsResult<T extends PagePropOpt = PagePropOpt> = {
     type: "success";
     error?: never;
@@ -15,7 +22,21 @@ type ResolvePageAndPropsResult<T extends PagePropOpt = PagePropOpt> = {
     PageComponent?: never;
     pageProps?: never;
 };
-export type ResolvePageAndPropsFn = <T extends PagePropOpt = PagePropOpt>(options: Pick<CreateHandlerOptions, "pagePath" | "pageExportName" | "propsPath" | "propsExportName" | "route" | "loader" | "moduleBaseURL" | "build">) => Promise<ResolvePageAndPropsResult<T>>;
-export declare const resolvePageAndProps: ResolvePageAndPropsFn;
+export type ResolvePageAndPropsFn = <T extends PagePropOpt = PagePropOpt>(options: Pick<CreateHandlerOptions, "pagePath" | "pageExportName" | "propsPath" | "propsExportName" | "loader" | "verbose" | "logger"> & {
+    moduleBaseURL?: string;
+    route?: string;
+    url?: string;
+    build?: {
+        rscOutputPath: string;
+        outDir?: never;
+        server?: never;
+        client?: never;
+        static?: never;
+        pages?: never;
+        pageExportName?: never;
+        propsExportName?: never;
+        rootExportName?: never;
+    };
+}) => Promise<ResolvePageAndPropsResult<T>>;
 export {};
 //# sourceMappingURL=resolvePageAndProps.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"resolvePageAndProps.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/resolvePageAndProps.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,oBAAoB,EACpB,iBAAiB,EACjB,WAAW,EACZ,MAAM,aAAa,CAAC;AAKrB,KAAK,yBAAyB,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,IAC9D;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,aAAa,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;IACpC,SAAS,EAAE,CAAC,CAAC;CACd,GACD;IACE,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,KAAK,CAAC;IACb,aAAa,CAAC,EAAE,KAAK,CAAC;IACtB,SAAS,CAAC,EAAE,KAAK,CAAC;CACnB,GACD;IACE,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,aAAa,CAAC,EAAE,KAAK,CAAC;IACtB,SAAS,CAAC,EAAE,KAAK,CAAC;CACnB,CAAC;AAEN,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EACtE,OAAO,EAAE,IAAI,CACX,oBAAoB,EAClB,UAAU,GACV,gBAAgB,GAChB,WAAW,GACX,iBAAiB,GACjB,OAAO,GACP,QAAQ,GACR,eAAe,GACf,OAAO,CACV,KACE,OAAO,CAAC,yBAAyB,CAAC,CAAC,CAAC,CAAC,CAAC;AAE3C,eAAO,MAAM,mBAAmB,EAAE,qBA4D/B,CAAC"}
+{"version":3,"file":"resolvePageAndProps.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/resolvePageAndProps.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,oBAAoB,EACpB,iBAAiB,EACjB,WAAW,EACZ,MAAM,aAAa,CAAC;AAKrB;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,EAAE,qBAmO/B,CAAC;AAEJ,KAAK,yBAAyB,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,IAC9D;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,aAAa,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC;IACpC,SAAS,EAAE,CAAC,CAAC;CACd,GACD;IACE,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,KAAK,CAAC;IACb,aAAa,CAAC,EAAE,KAAK,CAAC;IACtB,SAAS,CAAC,EAAE,KAAK,CAAC;CACnB,GACD;IACE,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,aAAa,CAAC,EAAE,KAAK,CAAC;IACtB,SAAS,CAAC,EAAE,KAAK,CAAC;CACnB,CAAC;AAEN,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EACtE,OAAO,EAAE,IAAI,CACX,oBAAoB,EAClB,UAAU,GACV,gBAAgB,GAChB,WAAW,GACX,iBAAiB,GACjB,QAAQ,GACR,SAAS,GACT,QAAQ,CACX,GAAG;IACF,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE;QACN,aAAa,EAAE,MAAM,CAAC;QACtB,MAAM,CAAC,EAAE,KAAK,CAAC;QACf,MAAM,CAAC,EAAE,KAAK,CAAC;QACf,MAAM,CAAC,EAAE,KAAK,CAAC;QACf,MAAM,CAAC,EAAE,KAAK,CAAC;QACf,KAAK,CAAC,EAAE,KAAK,CAAC;QACd,cAAc,CAAC,EAAE,KAAK,CAAC;QACvB,eAAe,CAAC,EAAE,KAAK,CAAC;QACxB,cAAc,CAAC,EAAE,KAAK,CAAC;KACxB,CAAC;CACH,KACE,OAAO,CAAC,yBAAyB,CAAC,CAAC,CAAC,CAAC,CAAC"}

package/dist/plugin/helpers/resolvePageAndProps.js

@@ -11,48 +11,189 @@ import { routeToURL } from '../utils/routeToURL.js';
 
 const resolvePageAndProps = async function _resolvePageAndProps(handlerOptions) {
   try {
-    const url = routeToURL(handlerOptions.route, handlerOptions.moduleBaseURL, handlerOptions.build.rscOutputPath);
+    if (handlerOptions.verbose) {
+      handlerOptions.logger?.info(
+        `[resolvePageAndProps] Starting resolution for route: ${handlerOptions.route}`
+      );
+    }
+    const url = handlerOptions.url ?? routeToURL(
+      handlerOptions.route ?? "",
+      handlerOptions.moduleBaseURL ?? "/",
+      handlerOptions?.build?.rscOutputPath ?? DEFAULT_CONFIG.BUILD.rscOutputPath
+    );
+    if (handlerOptions.verbose) {
+      handlerOptions.logger?.info(
+        `[resolvePageAndProps] URL resolved: ${url}. Starting page resolution`
+      );
+    }
     const resolvePagePromise = resolvePage({
       id: handlerOptions.pagePath,
       exportName: handlerOptions.pageExportName ?? DEFAULT_CONFIG.PAGE_EXPORT_NAME,
       loader: handlerOptions.loader
     });
+    if (handlerOptions.verbose) {
+      handlerOptions.logger?.info(
+        `[resolvePageAndProps] Starting props resolution`
+      );
+    }
     const resolvePropsPromise = resolveProps({
       url,
       id: handlerOptions.propsPath || handlerOptions.pagePath,
       exportName: handlerOptions.propsExportName ?? DEFAULT_CONFIG.PROPS_EXPORT_NAME,
-      loader: async () => {
+      loader: async (idWithExport) => {
+        if (handlerOptions.verbose) {
+          handlerOptions.logger?.info(
+            `[resolvePageAndProps] Props loader called with: ${idWithExport}`
+          );
+        }
+        let propsId = handlerOptions.propsPath || handlerOptions.pagePath;
+        let propsExportName = handlerOptions.propsExportName ?? DEFAULT_CONFIG.PROPS_EXPORT_NAME;
+        if (idWithExport && idWithExport.includes("#")) {
+          const [id, exportName] = idWithExport.split("#");
+          propsId = id;
+          if (exportName) {
+            propsExportName = exportName;
+          }
+        }
         const resolvePageResult2 = await resolvePagePromise;
         if (resolvePageResult2.type === "error") {
-          throw resolvePageResult2.error;
+          if (handlerOptions.verbose) {
+            handlerOptions.logger?.error("resolveProps", {
+              error: resolvePageResult2.error
+            });
+          }
+          if (resolvePageResult2.error != null) {
+            throw resolvePageResult2.error;
+          }
+          throw new Error("Failed to resolve page in props loader");
         }
-        if (resolvePageResult2.type === "success" && handlerOptions.propsExportName in resolvePageResult2.module) {
+        if (resolvePageResult2.type === "success" && propsExportName in resolvePageResult2.module) {
+          if (handlerOptions.verbose) {
+            handlerOptions.logger?.info(
+              `[resolvePageAndProps] Props found in page module`
+            );
+          }
           return resolvePageResult2.module;
         }
-        if (handlerOptions.propsPath) {
-          return handlerOptions.loader(handlerOptions.propsPath);
+        if (propsId && propsId !== handlerOptions.pagePath) {
+          if (handlerOptions.verbose) {
+            handlerOptions.logger?.info(
+              `[resolvePageAndProps] Loading props from separate file: ${propsId}`
+            );
+          }
+          const result = await handlerOptions.loader(propsId);
+          return result;
+        } else if (propsId === handlerOptions.pagePath) {
+          if (handlerOptions.verbose) {
+            handlerOptions.logger?.info(
+              `[resolvePageAndProps] Checking page module for props: ${propsId}`
+            );
+          }
+          if (resolvePageResult2.type === "success") {
+            const pageModule = resolvePageResult2.module;
+            if (propsExportName in pageModule) {
+              if (handlerOptions.verbose) {
+                handlerOptions.logger?.info(
+                  `[resolvePageAndProps] Props found in page module`
+                );
+              }
+              return pageModule;
+            }
+          }
+          const result = await handlerOptions.loader(propsId);
+          return result;
+        }
+        if (handlerOptions.verbose) {
+          handlerOptions.logger?.info(
+            `[resolvePageAndProps] Using default props with URL`
+          );
         }
         return {
-          [handlerOptions.propsExportName]: { url }
+          [propsExportName]: { url }
         };
       }
     });
+    if (handlerOptions.verbose) {
+      handlerOptions.logger?.info(
+        `[resolvePageAndProps] Waiting for both promises to resolve`
+      );
+    }
     const [resolvePageResult, resolvePropsResult] = await Promise.all([
       resolvePagePromise,
       resolvePropsPromise
     ]);
+    if (handlerOptions.verbose) {
+      handlerOptions.logger?.info(
+        `[resolvePageAndProps] Both promises resolved`
+      );
+    }
     if (resolvePageResult.type != "success") {
+      if (handlerOptions.verbose) {
+        handlerOptions.logger?.error(
+          `[resolvePageAndProps] Page resolution failed: ${resolvePageResult.type}`
+        );
+      }
       return resolvePageResult;
     }
     if (resolvePropsResult.type != "success") {
+      if (handlerOptions.verbose) {
+        handlerOptions.logger?.error(
+          `[resolvePageAndProps] Props resolution failed: ${resolvePropsResult.type}`
+        );
+      }
       return resolvePropsResult;
     }
+    if (handlerOptions.verbose) {
+      handlerOptions.logger?.info(
+        `[resolvePageAndProps] Both page and props resolved successfully`
+      );
+    }
+    let pageProps = resolvePropsResult.module?.[handlerOptions.propsExportName];
+    if (handlerOptions.verbose) {
+      handlerOptions.logger?.info(
+        `[resolvePageAndProps] Raw pageProps type: ${typeof pageProps}, isFunction: ${typeof pageProps === "function"}`
+      );
+    }
+    if (typeof pageProps === "function") {
+      if (handlerOptions.verbose) {
+        handlerOptions.logger?.info(
+          `[resolvePageAndProps] Props is a function, calling with url: ${url}`
+        );
+      }
+      try {
+        pageProps = pageProps(url);
+        if (pageProps instanceof Promise) {
+          pageProps = await pageProps;
+        }
+      } catch (error) {
+        if (handlerOptions.verbose) {
+          handlerOptions.logger?.error(
+            `[resolvePageAndProps] Error calling props function: ${error}`
+          );
+        }
+        pageProps = {};
+      }
+    }
+    if (handlerOptions.verbose) {
+      handlerOptions.logger?.info(
+        `[resolvePageAndProps] Extracted pageProps: ${JSON.stringify(Object.keys(pageProps || {}).length, null, 2)} keys`
+      );
+      handlerOptions.logger?.info(
+        `[resolvePageAndProps] resolvePropsResult.module keys: ${Object.keys(resolvePropsResult.module || {}).join(", ")}`
+      );
+    }
     return {
       type: "success",
       PageComponent: resolvePageResult.module[handlerOptions.pageExportName],
-      pageProps: resolvePropsResult.module?.[handlerOptions.propsExportName]
+      pageProps: pageProps ?? {}
+      // Ensure pageProps is always an object, not undefined
     };
   } catch (error) {
+    if (handlerOptions.verbose) {
+      handlerOptions.logger?.error(
+        `[resolvePageAndProps] Error in resolvePageAndProps: ${error}`
+      );
+    }
     return {
       type: "error",
       error: toError(error)
@@ -61,4 +202,4 @@ const resolvePageAndProps = async function _resolvePageAndProps(handlerOptions)
 };
 
 export { resolvePageAndProps };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"resolvePageAndProps.js","sources":["../../../plugin/helpers/resolvePageAndProps.ts"],"sourcesContent":["import { DEFAULT_CONFIG } from \"../config/defaults.js\";\nimport { toError } from \"../error/toError.js\";\nimport type {\n  CreateHandlerOptions,\n  PageComponentType,\n  PagePropOpt,\n} from \"../types.js\";\nimport { resolvePage } from \"./resolvePage.js\";\nimport { resolveProps } from \"./resolveProps.js\";\nimport { routeToURL } from \"../utils/routeToURL.js\";\n\n/**\n * Resolves the page and props for a given route, works in combination with resolveComponents\n * The special thing it does is that if the props is already in the page module, it will fallback to that.\n * @param handlerOptions - The handler options.\n * @returns The resolved page and props.\n */\nexport const resolvePageAndProps: ResolvePageAndPropsFn =\n  async function _resolvePageAndProps(handlerOptions) {\n    try {\n      if (handlerOptions.verbose) {\n        handlerOptions.logger?.info(\n          `[resolvePageAndProps] Starting resolution for route: ${handlerOptions.route}`\n        );\n      }\n\n      const url =\n        handlerOptions.url ??\n        routeToURL(\n          handlerOptions.route ?? \"\",\n          handlerOptions.moduleBaseURL ?? \"/\",\n          handlerOptions?.build?.rscOutputPath ??\n            DEFAULT_CONFIG.BUILD.rscOutputPath\n        );\n\n      if (handlerOptions.verbose) {\n        handlerOptions.logger?.info(\n          `[resolvePageAndProps] URL resolved: ${url}. Starting page resolution`\n        );\n      }\n\n      const resolvePagePromise = resolvePage({\n        id: handlerOptions.pagePath,\n        exportName:\n          handlerOptions.pageExportName ?? DEFAULT_CONFIG.PAGE_EXPORT_NAME,\n        loader: handlerOptions.loader,\n      });\n\n      if (handlerOptions.verbose) {\n        handlerOptions.logger?.info(\n          `[resolvePageAndProps] Starting props resolution`\n        );\n      }\n\n      const resolvePropsPromise = resolveProps({\n        url,\n        id: handlerOptions.propsPath || handlerOptions.pagePath,\n        exportName:\n          handlerOptions.propsExportName ?? DEFAULT_CONFIG.PROPS_EXPORT_NAME,\n        loader: async (idWithExport?: string) => {\n          if (handlerOptions.verbose) {\n            handlerOptions.logger?.info(\n              `[resolvePageAndProps] Props loader called with: ${idWithExport}`\n            );\n          }\n          \n          // Parse the id to extract the path and export name if using # syntax\n          let propsId = handlerOptions.propsPath || handlerOptions.pagePath;\n          let propsExportName = handlerOptions.propsExportName ?? DEFAULT_CONFIG.PROPS_EXPORT_NAME;\n          \n          if (idWithExport && idWithExport.includes('#')) {\n            const [id, exportName] = idWithExport.split('#');\n            propsId = id;\n            if (exportName) {\n              propsExportName = exportName;\n            }\n          }\n          \n          const resolvePageResult = await resolvePagePromise;\n          if (resolvePageResult.type === \"error\") {\n            if (handlerOptions.verbose) {\n              handlerOptions.logger?.error(\"resolveProps\", {\n                error: resolvePageResult.error,\n              });\n            }\n            if (resolvePageResult.error != null) {\n              throw resolvePageResult.error;\n            }\n            throw new Error(\"Failed to resolve page in props loader\");\n          }\n          if (\n            resolvePageResult.type === \"success\" &&\n            propsExportName in resolvePageResult.module\n          ) {\n            if (handlerOptions.verbose) {\n              handlerOptions.logger?.info(\n                `[resolvePageAndProps] Props found in page module`\n              );\n            }\n            // return the module\n            return resolvePageResult.module;\n          }\n          if (propsId && propsId !== handlerOptions.pagePath) {\n            // Separate props file\n            if (handlerOptions.verbose) {\n              handlerOptions.logger?.info(\n                `[resolvePageAndProps] Loading props from separate file: ${propsId}`\n              );\n            }\n            const result = await handlerOptions.loader(propsId);\n            return result;\n          } else if (propsId === handlerOptions.pagePath) {\n            // Props might be in the page module\n            if (handlerOptions.verbose) {\n              handlerOptions.logger?.info(\n                `[resolvePageAndProps] Checking page module for props: ${propsId}`\n              );\n            }\n            if (resolvePageResult.type === \"success\") {\n              const pageModule = resolvePageResult.module;\n              if (propsExportName in pageModule) {\n                if (handlerOptions.verbose) {\n                  handlerOptions.logger?.info(\n                    `[resolvePageAndProps] Props found in page module`\n                  );\n                }\n                return pageModule;\n              }\n            }\n            // Try loading the page module directly\n            const result = await handlerOptions.loader(propsId);\n            return result;\n          }\n          if (handlerOptions.verbose) {\n            handlerOptions.logger?.info(\n              `[resolvePageAndProps] Using default props with URL`\n            );\n          }\n          return {\n            [propsExportName]: { url: url },\n          };\n        },\n      });\n\n      if (handlerOptions.verbose) {\n        handlerOptions.logger?.info(\n          `[resolvePageAndProps] Waiting for both promises to resolve`\n        );\n      }\n\n      const [resolvePageResult, resolvePropsResult] = await Promise.all([\n        resolvePagePromise,\n        resolvePropsPromise,\n      ]);\n\n      if (handlerOptions.verbose) {\n        handlerOptions.logger?.info(\n          `[resolvePageAndProps] Both promises resolved`\n        );\n      }\n\n      if (resolvePageResult.type != \"success\") {\n        if (handlerOptions.verbose) {\n          handlerOptions.logger?.error(\n            `[resolvePageAndProps] Page resolution failed: ${resolvePageResult.type}`\n          );\n        }\n        return resolvePageResult;\n      }\n      if (resolvePropsResult.type != \"success\") {\n        if (handlerOptions.verbose) {\n          handlerOptions.logger?.error(\n            `[resolvePageAndProps] Props resolution failed: ${resolvePropsResult.type}`\n          );\n        }\n        return resolvePropsResult;\n      }\n\n      if (handlerOptions.verbose) {\n        handlerOptions.logger?.info(\n          `[resolvePageAndProps] Both page and props resolved successfully`\n        );\n      }\n\n      let pageProps = resolvePropsResult.module?.[\n        handlerOptions.propsExportName as keyof typeof resolvePropsResult.module\n      ] as any;\n\n      if (handlerOptions.verbose) {\n        handlerOptions.logger?.info(\n          `[resolvePageAndProps] Raw pageProps type: ${typeof pageProps}, isFunction: ${typeof pageProps === \"function\"}`\n        );\n      }\n\n      // If props is a function, call it with the URL\n      if (typeof pageProps === \"function\") {\n        if (handlerOptions.verbose) {\n          handlerOptions.logger?.info(\n            `[resolvePageAndProps] Props is a function, calling with url: ${url}`\n          );\n        }\n        try {\n          pageProps = pageProps(url);\n          // Await if it returns a Promise\n          if (pageProps instanceof Promise) {\n            pageProps = await pageProps;\n          }\n        } catch (error) {\n          if (handlerOptions.verbose) {\n            handlerOptions.logger?.error(\n              `[resolvePageAndProps] Error calling props function: ${error}`\n            );\n          }\n          pageProps = {};\n        }\n      }\n\n      if (handlerOptions.verbose) {\n        handlerOptions.logger?.info(\n          `[resolvePageAndProps] Extracted pageProps: ${JSON.stringify(Object.keys(pageProps || {}).length, null, 2)} keys`\n        );\n        handlerOptions.logger?.info(\n          `[resolvePageAndProps] resolvePropsResult.module keys: ${Object.keys(resolvePropsResult.module || {}).join(\", \")}`\n        );\n      }\n\n      return {\n        type: \"success\" as const,\n        PageComponent: resolvePageResult.module[\n          handlerOptions.pageExportName\n        ] as never,\n        pageProps: pageProps ?? {}, // Ensure pageProps is always an object, not undefined\n      };\n    } catch (error) {\n      if (handlerOptions.verbose) {\n        handlerOptions.logger?.error(\n          `[resolvePageAndProps] Error in resolvePageAndProps: ${error}`\n        );\n      }\n      return {\n        type: \"error\" as const,\n        error: toError(error),\n      };\n    }\n  };\n\ntype ResolvePageAndPropsResult<T extends PagePropOpt = PagePropOpt> =\n  | {\n      type: \"success\";\n      error?: never;\n      PageComponent: PageComponentType<T>;\n      pageProps: T;\n    }\n  | {\n      type: \"error\";\n      error: Error;\n      PageComponent?: never;\n      pageProps?: never;\n    }\n  | {\n      type: \"skip\";\n      error?: never;\n      PageComponent?: never;\n      pageProps?: never;\n    };\n\nexport type ResolvePageAndPropsFn = <T extends PagePropOpt = PagePropOpt>(\n  options: Pick<\n    CreateHandlerOptions,\n    | \"pagePath\"\n    | \"pageExportName\"\n    | \"propsPath\"\n    | \"propsExportName\"\n    | \"loader\"\n    | \"verbose\"\n    | \"logger\"\n  > & {\n    moduleBaseURL?: string;\n    route?: string;\n    url?: string;\n    build?: {\n      rscOutputPath: string;\n      outDir?: never;\n      server?: never;\n      client?: never;\n      static?: never;\n      pages?: never;\n      pageExportName?: never;\n      propsExportName?: never;\n      rootExportName?: never;\n    };\n  }\n) => Promise<ResolvePageAndPropsResult<T>>;\n"],"names":["resolvePageResult"],"mappings":"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"}

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

@@ -0,0 +1,11 @@
+import type { ResolvedUserOptions } from "../types.js";
+import type { RscRenderMessage } from "../worker/rsc/types.js";
+/**
+ * Resolves the URL for the render operation, either from message or computed from route
+ *
+ * @param message - The RSC render message containing route information
+ * @param userOptions - User options containing module base URL and build configuration
+ * @returns The resolved URL for the render operation
+ */
+export declare function resolveRenderUrl(message: RscRenderMessage, userOptions: ResolvedUserOptions): string;
+//# sourceMappingURL=resolveRenderUrl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolveRenderUrl.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/resolveRenderUrl.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAEvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,gBAAgB,EACzB,WAAW,EAAE,mBAAmB,GAC/B,MAAM,CAUR"}

package/dist/plugin/helpers/resolveRenderUrl.js

@@ -0,0 +1,19 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { DEFAULT_CONFIG } from '../config/defaults.js';
+import { routeToURL } from '../utils/routeToURL.js';
+
+function resolveRenderUrl(message, userOptions) {
+  const options = message.options || {};
+  return options.url ?? routeToURL(
+    options.route,
+    userOptions.moduleBaseURL,
+    userOptions.build?.rscOutputPath ?? DEFAULT_CONFIG.BUILD.rscOutputPath
+  );
+}
+
+export { resolveRenderUrl };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzb2x2ZVJlbmRlclVybC5qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcGx1Z2luL2hlbHBlcnMvcmVzb2x2ZVJlbmRlclVybC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBERUZBVUxUX0NPTkZJRyB9IGZyb20gXCIuLi9jb25maWcvaW5kZXguanNcIjtcbmltcG9ydCB0eXBlIHsgUmVzb2x2ZWRVc2VyT3B0aW9ucyB9IGZyb20gXCIuLi90eXBlcy5qc1wiO1xuaW1wb3J0IHsgcm91dGVUb1VSTCB9IGZyb20gXCIuLi91dGlscy9yb3V0ZVRvVVJMLmpzXCI7XG5pbXBvcnQgdHlwZSB7IFJzY1JlbmRlck1lc3NhZ2UgfSBmcm9tIFwiLi4vd29ya2VyL3JzYy90eXBlcy5qc1wiO1xuXG4vKipcbiAqIFJlc29sdmVzIHRoZSBVUkwgZm9yIHRoZSByZW5kZXIgb3BlcmF0aW9uLCBlaXRoZXIgZnJvbSBtZXNzYWdlIG9yIGNvbXB1dGVkIGZyb20gcm91dGVcbiAqIFxuICogQHBhcmFtIG1lc3NhZ2UgLSBUaGUgUlNDIHJlbmRlciBtZXNzYWdlIGNvbnRhaW5pbmcgcm91dGUgaW5mb3JtYXRpb25cbiAqIEBwYXJhbSB1c2VyT3B0aW9ucyAtIFVzZXIgb3B0aW9ucyBjb250YWluaW5nIG1vZHVsZSBiYXNlIFVSTCBhbmQgYnVpbGQgY29uZmlndXJhdGlvblxuICogQHJldHVybnMgVGhlIHJlc29sdmVkIFVSTCBmb3IgdGhlIHJlbmRlciBvcGVyYXRpb25cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHJlc29sdmVSZW5kZXJVcmwoXG4gIG1lc3NhZ2U6IFJzY1JlbmRlck1lc3NhZ2UsXG4gIHVzZXJPcHRpb25zOiBSZXNvbHZlZFVzZXJPcHRpb25zXG4pOiBzdHJpbmcge1xuICBjb25zdCBvcHRpb25zID0gbWVzc2FnZS5vcHRpb25zIHx8IHt9O1xuICByZXR1cm4gKFxuICAgIG9wdGlvbnMudXJsID8/XG4gICAgcm91dGVUb1VSTChcbiAgICAgIG9wdGlvbnMucm91dGUsXG4gICAgICB1c2VyT3B0aW9ucy5tb2R1bGVCYXNlVVJMLFxuICAgICAgdXNlck9wdGlvbnMuYnVpbGQ/LnJzY091dHB1dFBhdGggPz8gREVGQVVMVF9DT05GSUcuQlVJTEQucnNjT3V0cHV0UGF0aFxuICAgIClcbiAgKTtcbn1cbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7OztBQVlPLFNBQVMsZ0JBQUEsQ0FDZCxTQUNBLFdBQ1EsRUFBQTtBQUNSLEVBQU0sTUFBQSxPQUFBLEdBQVUsT0FBUSxDQUFBLE9BQUEsSUFBVyxFQUFDO0FBQ3BDLEVBQUEsT0FDRSxRQUFRLEdBQ1IsSUFBQSxVQUFBO0FBQUEsSUFDRSxPQUFRLENBQUEsS0FBQTtBQUFBLElBQ1IsV0FBWSxDQUFBLGFBQUE7QUFBQSxJQUNaLFdBQVksQ0FBQSxLQUFBLEVBQU8sYUFBaUIsSUFBQSxjQUFBLENBQWUsS0FBTSxDQUFBO0FBQUEsR0FDM0Q7QUFFSjs7OzsifQ==

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

@@ -0,0 +1,14 @@
+import type { ResolveStreamElementsOptions } from "./resolveStreamElements.types.js";
+/**
+ * Client version of resolveStreamElements.
+ *
+ * Strategy: Get RSC stream from worker and convert to React elements.
+ * This involves:
+ * 1. Getting or creating a PassThrough stream for the route
+ * 2. Converting the RSC stream to React elements using ReactDOMClient.createFromNodeStream
+ * 3. Returning the React elements for client-side hydration
+ */
+export declare function resolveStreamElements(options: ResolveStreamElementsOptions): Promise<import("../stream/createFromNodeStream.types.js").FromNodeStreamResult & {
+    type: "client";
+}>;
+//# sourceMappingURL=resolveStreamElements.client.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolveStreamElements.client.d.ts","sourceRoot":"","sources":["../../../plugin/helpers/resolveStreamElements.client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,4BAA4B,EAAE,MAAM,kCAAkC,CAAC;AAYrF;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,4BAA4B;;GA2BtC"}