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

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

@@ -0,0 +1,18 @@
+import { performance } from "node:perf_hooks";
+import { assertReactServer } from "../config/getCondition.js";
+assertReactServer();
+export const reactServerPlugin = function _reactServerPlugin(_options) {
+    const timing = {
+        start: performance.now(),
+    };
+    return {
+        name: "vite:plugin-react-server/server",
+        enforce: "post",
+        api: {
+            meta: { timing },
+        },
+        configResolved(_resolvedConfig) {
+            timing.configResolved = performance.now();
+        },
+    };
+};

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

@@ -0,0 +1,11 @@
+import type { Manifest, ViteDevServer } from "vite";
+import type { AutoDiscoveredFiles, CreateHandlerOptions, ResolvedUserOptions } from "../types.js";
+import type { IncomingMessage, ServerResponse } from "http";
+export type HandleServerActionFn = (req: IncomingMessage, res: ServerResponse, server: ViteDevServer, handlerOptions: Pick<CreateHandlerOptions, "verbose" | "moduleBasePath" | "projectRoot" | "loader">) => Promise<void>;
+export type ConfigureReactServerFn = (options: {
+    server: ViteDevServer;
+    autoDiscoveredFiles: AutoDiscoveredFiles;
+    userOptions: ResolvedUserOptions;
+    serverManifest: Manifest;
+}) => void;
+//# sourceMappingURL=types.d.ts.map

package/dist/plugin/react-server/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../plugin/react-server/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AACpD,OAAO,KAAK,EACV,mBAAmB,EACnB,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAE5D,MAAM,MAAM,oBAAoB,GAAG,CACjC,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,MAAM,EAAE,aAAa,EACrB,cAAc,EAAE,IAAI,CAClB,oBAAoB,EACpB,SAAS,GAAG,gBAAgB,GAAG,aAAa,GAAG,QAAQ,CACxD,KACE,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnB,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,EAAE;IAC7C,MAAM,EAAE,aAAa,CAAC;IACtB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,WAAW,EAAE,mBAAmB,CAAC;IACjC,cAAc,EAAE,QAAQ,CAAC;CAC1B,KAAK,IAAI,CAAC"}

package/dist/plugin/react-server/types.js

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

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

@@ -0,0 +1,15 @@
+/**
+ * collectHtmlContent.client.ts
+ *
+ * PURPOSE: Collects HTML stream with metrics
+ *
+ * This module:
+ * 1. Takes an HTML stream and collects it
+ * 2. Tracks metrics (chunks, bytes, duration)
+ * 3. Returns buffered content and metrics
+ * 4. Does NOT create HTML streams - that's the caller's responsibility
+ * 5. Does NOT write files - that's the caller's responsibility
+ */
+import type { CollectHtmlContentFn } from "./types.js";
+export declare const collectHtmlContent: CollectHtmlContentFn;
+//# sourceMappingURL=collectHtmlContent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collectHtmlContent.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/collectHtmlContent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAEvD,eAAO,MAAM,kBAAkB,EAAE,oBAiH9B,CAAC"}

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

@@ -0,0 +1,104 @@
+/**
+ * collectHtmlContent.client.ts
+ *
+ * PURPOSE: Collects HTML stream with metrics
+ *
+ * This module:
+ * 1. Takes an HTML stream and collects it
+ * 2. Tracks metrics (chunks, bytes, duration)
+ * 3. Returns buffered content and metrics
+ * 4. Does NOT create HTML streams - that's the caller's responsibility
+ * 5. Does NOT write files - that's the caller's responsibility
+ */
+import { Transform } from "node:stream";
+import { createStreamMetrics } from "../metrics/createStreamMetrics.js";
+export const collectHtmlContent = async function _collectHtmlContent(html, handlerOptions) {
+    const metrics = createStreamMetrics();
+    const startTime = performance.now();
+    const htmlBuffer = [];
+    if (handlerOptions.verbose) {
+        handlerOptions.logger.info(`[collectHtmlContent.client] Starting HTML collection for route: ${handlerOptions.route}`);
+    }
+    try {
+        // Create a transform stream to collect HTML content and track metrics
+        const metricsTransform = new Transform({
+            transform(chunk, encoding, callback) {
+                const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
+                htmlBuffer.push(buffer);
+                metrics.chunks++;
+                metrics.bytes += buffer.length;
+                if (handlerOptions.verbose) {
+                    handlerOptions.logger.info(`[collectHtmlContent.client] HTML chunk ${metrics.chunks}, bytes: ${buffer.length}, total: ${metrics.bytes}`);
+                }
+                callback(null, chunk);
+            },
+            flush(callback) {
+                metrics.duration = performance.now() - startTime;
+                if (handlerOptions.verbose) {
+                    handlerOptions.logger.info(`[collectHtmlContent.client] HTML collection completed: ${metrics.bytes} bytes in ${metrics.duration}ms`);
+                }
+                callback();
+            }
+        });
+        // Create a PassThrough stream to consume the transform
+        const { PassThrough } = await import("node:stream");
+        const consumer = new PassThrough();
+        // Pipe HTML stream through metrics tracking to consumer
+        html.pipe(metricsTransform).pipe(consumer);
+        // Wait for stream to complete with timeout
+        await new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                if (handlerOptions.verbose) {
+                    handlerOptions.logger.info(`[collectHtmlContent.client] Stream timeout reached, forcing completion`);
+                }
+                resolve();
+            }, 15000); // 15 second timeout for HTML content collection
+            consumer.on("end", () => {
+                if (handlerOptions.verbose) {
+                    handlerOptions.logger.info(`[collectHtmlContent.client] Stream ended with ${metrics.bytes} bytes`);
+                }
+                clearTimeout(timeout);
+                resolve();
+            });
+            consumer.on("error", (error) => {
+                if (handlerOptions.verbose) {
+                    handlerOptions.logger.info(`[collectHtmlContent.client] Stream error: ${error}`);
+                }
+                clearTimeout(timeout);
+                reject(error);
+            });
+        });
+        // Create a readable stream from the buffered content that can be piped multiple times
+        const { Readable } = await import("node:stream");
+        const readableStream = new Readable({
+            read() {
+                // Push all buffered content
+                for (const chunk of htmlBuffer) {
+                    this.push(chunk);
+                }
+                this.push(null); // End the stream
+            }
+        });
+        // Return buffered content and metrics - file writing is caller's responsibility
+        return {
+            pipe: readableStream.pipe.bind(readableStream),
+            abort: (reason) => {
+                html.abort(reason);
+                readableStream.destroy(reason);
+            },
+            metrics,
+            // Include buffered content for reuse
+            bufferedContent: htmlBuffer,
+        };
+    }
+    catch (error) {
+        if (handlerOptions.verbose) {
+            handlerOptions.logger.info(`[collectHtmlContent.client] Error: ${error}`);
+        }
+        html.abort(new Error("HTML Stream aborted"));
+        if (error != null) {
+            throw error;
+        }
+        throw new Error("Failed to collect HTML content");
+    }
+};

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

@@ -1,26 +1,21 @@
 /**
- * rscHandler.ts
+ * collectRscContent.ts
  *
- * PURPOSE: Handles collecting RSC content from the rscHeadless stream
+ * PURPOSE: Collects RSC content from a stream with metrics
  *
  * This module:
- * 1. Collects RSC content from the rscHeadless stream
- * 2. Returns the complete RSC content when the stream is done
- * 3. Provides a clean interface for RSC handling
+ * 1. Collects RSC content from the provided stream
+ * 2. Tracks metrics (chunks, bytes, duration)
+ * 3. Returns buffered content and metrics
+ * 4. Does NOT write files - that's the caller's responsibility
  */
-import type { PassThrough } from "node:stream";
-import type { CreateHandlerOptions, StreamMetrics } from "../types.js";
-export type CollectRscContentReturn = Promise<{
-    stream: PassThrough;
-    metrics: StreamMetrics;
-}>;
-export type CollectRscContentFn = (rscStream: PassThrough, handlerOptions: CreateHandlerOptions) => CollectRscContentReturn;
+import type { CollectRscContentFn } from "./types.js";
 /**
- * Collects RSC content from the rscHeadless stream
+ * Collects RSC content from a stream with metrics
  *
- * @param rscStream The stream containing the RSC content
+ * @param rsc The stream containing the RSC content
  * @param handlerOptions The options for the handler
- * @returns A promise that resolves with the complete RSC content and metrics
+ * @returns A promise that resolves with buffered content and metrics
  */
 export declare const collectRscContent: CollectRscContentFn;
 //# sourceMappingURL=collectRscContent.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"collectRscContent.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/collectRscContent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI/C,OAAO,KAAK,EACV,oBAAoB,EACpB,aAAa,EACd,MAAM,aAAa,CAAC;AAIrB,MAAM,MAAM,uBAAuB,GAAG,OAAO,CAAC;IAC5C,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,EAAE,aAAa,CAAC;CACxB,CAAC,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAChC,SAAS,EAAE,WAAW,EACtB,cAAc,EAAE,oBAAoB,KACjC,uBAAuB,CAAC;AAE7B;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,EAAE,mBAiD7B,CAAC"}
+{"version":3,"file":"collectRscContent.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/collectRscContent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,EAAE,mBA4G7B,CAAC"}

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

@@ -4,46 +4,97 @@
  * MIT License
  */
 import { Transform } from 'node:stream';
-import { join, dirname } from 'node:path';
-import { mkdir } from 'node:fs/promises';
 import { createStreamMetrics } from '../metrics/createStreamMetrics.js';
-import { fileWriter } from './fileWriter.js';
 
-const collectRscContent = async function _collectRscContent(rscStream, handlerOptions) {
+const collectRscContent = async function _collectRscContent(rsc, handlerOptions) {
   const metrics = createStreamMetrics();
   const startTime = performance.now();
-  const outputPath = join(
-    handlerOptions.build.outDir,
-    handlerOptions.build.static,
-    handlerOptions.route,
-    handlerOptions.build.rscOutputPath
-  );
-  const dir = dirname(outputPath);
-  await mkdir(join(handlerOptions.projectRoot, dir), { recursive: true });
+  const rscBuffer = [];
   const metricsTransform = new Transform({
     transform(chunk, _encoding, callback) {
       metrics.chunks++;
       metrics.bytes += chunk.length;
+      rscBuffer.push(Buffer.from(chunk));
       callback(null, chunk);
     },
     flush(callback) {
       metrics.duration = performance.now() - startTime;
+      if (handlerOptions.verbose) {
+        handlerOptions.logger.info(
+          `[collectRscContent] Transform flush: ${metrics.chunks} chunks, ${metrics.duration}ms`
+        );
+      }
       callback();
     }
   });
   try {
-    rscStream.pipe(metricsTransform);
-    const writePromise = fileWriter(metricsTransform, "rsc", handlerOptions);
-    await new Promise((resolve) => {
-      metricsTransform.on("end", resolve);
+    const { PassThrough } = await import('node:stream');
+    const consumer = new PassThrough();
+    rsc.pipe(metricsTransform).pipe(consumer);
+    await new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        if (handlerOptions.verbose) {
+          handlerOptions.logger.info(
+            `[collectRscContent] Stream timeout reached, forcing completion`
+          );
+        }
+        resolve();
+      }, handlerOptions.rscTimeout || 5e3);
+      consumer.on("end", () => {
+        if (handlerOptions.verbose) {
+          handlerOptions.logger.info(
+            `[collectRscContent] Stream ended with ${metrics.bytes} bytes`
+          );
+        }
+        clearTimeout(timeout);
+        resolve();
+      });
+      consumer.on("error", (error) => {
+        if (handlerOptions.verbose) {
+          handlerOptions.logger.info(
+            `[collectRscContent] Stream error: ${error}`
+          );
+        }
+        clearTimeout(timeout);
+        reject(error);
+      });
     });
-    await writePromise;
-    return { stream: rscStream, metrics };
+    if (handlerOptions.verbose) {
+      handlerOptions.logger.info(
+        `[collectRscContent] Collection completed with ${metrics.bytes} bytes`
+      );
+    }
+    const { Readable } = await import('node:stream');
+    const readableStream = new Readable({
+      read() {
+        for (const chunk of rscBuffer) {
+          this.push(chunk);
+        }
+        this.push(null);
+      }
+    });
+    return {
+      pipe: readableStream.pipe.bind(readableStream),
+      abort: (reason) => {
+        rsc.abort(reason);
+        readableStream.destroy(reason);
+      },
+      metrics,
+      // Include buffered content for reuse
+      bufferedContent: rscBuffer
+    };
   } catch (error) {
+    if (handlerOptions.verbose) {
+      handlerOptions.logger.info(`[collectRscContent] Error: ${error}`);
+    }
     metricsTransform.destroy();
-    throw error;
+    rsc.abort(new Error("RSC Stream aborted"));
+    if (error != null) {
+      throw error;
+    }
+    throw new Error("Failed to collect RSC content");
   }
 };
 
 export { collectRscContent };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"collectRscContent.js","sources":["../../../plugin/react-static/collectRscContent.ts"],"sourcesContent":["/**\n * collectRscContent.ts\n *\n * PURPOSE: Collects RSC content from a stream with metrics\n *\n * This module:\n * 1. Collects RSC content from the provided stream\n * 2. Tracks metrics (chunks, bytes, duration)\n * 3. Returns buffered content and metrics\n * 4. Does NOT write files - that's the caller's responsibility\n */\n\nimport { Transform } from \"node:stream\";\nimport { createStreamMetrics } from \"../metrics/createStreamMetrics.js\";\nimport type { CollectRscContentFn } from \"./types.js\";\n\n/**\n * Collects RSC content from a stream with metrics\n *\n * @param rsc The stream containing the RSC content\n * @param handlerOptions The options for the handler\n * @returns A promise that resolves with buffered content and metrics\n */\nexport const collectRscContent: CollectRscContentFn =\n  async function _collectRscContent(rsc, handlerOptions) {\n    const metrics = createStreamMetrics();\n    const startTime = performance.now();\n\n    // Buffer to store RSC content for reuse\n    const rscBuffer: Buffer[] = [];\n\n    // Create transform to track metrics and buffer content\n    const metricsTransform = new Transform({\n      transform(chunk, _encoding, callback) {\n        metrics.chunks++;\n        metrics.bytes += chunk.length;\n        // Buffer the chunk for reuse\n        rscBuffer.push(Buffer.from(chunk));\n        callback(null, chunk);\n      },\n      flush(callback) {\n        metrics.duration = performance.now() - startTime;\n        if (handlerOptions.verbose) {\n          handlerOptions.logger.info(\n            `[collectRscContent] Transform flush: ${metrics.chunks} chunks, ${metrics.duration}ms`\n          );\n        }\n        callback();\n      },\n    });\n\n    try {\n      // Create a PassThrough stream to consume the transform\n      const { PassThrough } = await import(\"node:stream\");\n      const consumer = new PassThrough();\n      \n      // Pipe RSC stream through metrics tracking to consumer\n      rsc.pipe(metricsTransform).pipe(consumer);\n\n      // Wait for stream to complete with timeout\n      await new Promise<void>((resolve, reject) => {\n        const timeout = setTimeout(() => {\n          if (handlerOptions.verbose) {\n            handlerOptions.logger.info(\n              `[collectRscContent] Stream timeout reached, forcing completion`\n            );\n          }\n          resolve();\n        }, handlerOptions.rscTimeout || 5000); // 5 second timeout\n\n        consumer.on(\"end\", () => {\n          if (handlerOptions.verbose) {\n            handlerOptions.logger.info(\n              `[collectRscContent] Stream ended with ${metrics.bytes} bytes`\n            );\n          }\n          clearTimeout(timeout);\n          resolve();\n        });\n\n        consumer.on(\"error\", (error) => {\n          if (handlerOptions.verbose) {\n            handlerOptions.logger.info(\n              `[collectRscContent] Stream error: ${error}`\n            );\n          }\n          clearTimeout(timeout);\n          reject(error);\n        });\n      });\n\n      if (handlerOptions.verbose) {\n        handlerOptions.logger.info(\n          `[collectRscContent] Collection completed with ${metrics.bytes} bytes`\n        );\n      }\n\n      // Create a readable stream from the buffered content that can be piped multiple times\n      const { Readable } = await import(\"node:stream\");\n      const readableStream = new Readable({\n        read() {\n          // Push all buffered content\n          for (const chunk of rscBuffer) {\n            this.push(chunk);\n          }\n          this.push(null); // End the stream\n        }\n      });\n\n      // Return buffered content and metrics - file writing is caller's responsibility\n      return {\n        pipe: readableStream.pipe.bind(readableStream),\n        abort: (reason?: unknown) => {\n          rsc.abort(reason);\n          readableStream.destroy(reason as Error);\n        },\n        metrics,\n        // Include buffered content for reuse\n        bufferedContent: rscBuffer,\n      };\n    } catch (error) {\n      if (handlerOptions.verbose) {\n        handlerOptions.logger.info(`[collectRscContent] Error: ${error}`);\n      }\n      metricsTransform.destroy();\n      rsc.abort(new Error(\"RSC Stream aborted\"));\n      if (error != null) {\n        throw error;\n      }\n      throw new Error(\"Failed to collect RSC content\");\n    }\n  };\n"],"names":[],"mappings":"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"}

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

@@ -1,9 +1,3 @@
-import type { PreviewServer } from "vite";
-import type { ResolvedUserOptions } from "../types.js";
-export type ConfigurePreviewServerProps<Opt extends ResolvedUserOptions> = {
-    server: PreviewServer;
-    userOptions: Opt;
-};
-export type ConfigurePreviewServerFn = <Opt extends ResolvedUserOptions>(props: ConfigurePreviewServerProps<Opt>) => Promise<void>;
+import type { ConfigurePreviewServerFn } from "./types.js";
 export declare const configurePreviewServer: ConfigurePreviewServerFn;
 //# sourceMappingURL=configurePreviewServer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"configurePreviewServer.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/configurePreviewServer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAC1C,OAAO,KAAK,EACV,mBAAmB,EAEpB,MAAM,aAAa,CAAC;AAOrB,MAAM,MAAM,2BAA2B,CAAC,GAAG,SAAS,mBAAmB,IAAI;IACzE,MAAM,EAAE,aAAa,CAAC;IACtB,WAAW,EAAE,GAAG,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,GAAG,SAAS,mBAAmB,EACrE,KAAK,EAAE,2BAA2B,CAAC,GAAG,CAAC,KACpC,OAAO,CAAC,IAAI,CAAC,CAAC;AAEnB,eAAO,MAAM,sBAAsB,EAAE,wBAgHlC,CAAC"}
+{"version":3,"file":"configurePreviewServer.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/configurePreviewServer.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AAE3D,eAAO,MAAM,sBAAsB,EAAE,wBAoGlC,CAAC"}

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

@@ -8,23 +8,27 @@ import { createReadStream } from 'node:fs';
 import { stat } from 'node:fs/promises';
 import { pipeline } from 'node:stream/promises';
 import { requestInfo } from '../helpers/requestInfo.js';
+import { logError } from '../error/logError.js';
 
-const configurePreviewServer = async function _configurePreviewServer({ server, userOptions }) {
+const configurePreviewServer = function _configurePreviewServer({ server, userOptions }) {
   const staticHostDir = join(
     userOptions.projectRoot,
     userOptions.build.outDir,
     userOptions.build.static
   );
-  console.log(userOptions.moduleBaseURL, userOptions.moduleBasePath);
   server.middlewares.use(async (req, res, next) => {
     if (!req.url) {
       return next();
     }
+    const logger = server.config.customLogger || server.config.logger;
+    const handlerOptions = {
+      ...userOptions,
+      logger
+    };
     const { contentType, filePath, isRscRequest } = requestInfo(
       req,
-      userOptions,
-      staticHostDir,
-      server.config.logger
+      handlerOptions,
+      staticHostDir
     );
     if (filePath && isRscRequest) {
       try {
@@ -42,7 +46,7 @@ const configurePreviewServer = async function _configurePreviewServer({ server,
             const readStream = createReadStream(filePath);
             readStream.on("error", () => {
               if (!res.writable) {
-                controller.abort();
+                controller.abort("aborted by preview server");
               }
             });
             await pipeline(readStream, res, { signal });
@@ -56,21 +60,10 @@ const configurePreviewServer = async function _configurePreviewServer({ server,
                 }
               } else if (streamError.code === "ENOENT") {
                 res.statusCode = 404;
-                server.config.logger.error(
-                  `File not found: ${filePath}. ${streamError.message}`,
-                  {
-                    error: streamError
-                  }
-                );
-                console.log("File not found: ", filePath);
+                logError(streamError, logger);
                 res.end("File not found");
               } else {
-                server.config.logger.error(
-                  `Error loading file: ${filePath}. ${streamError.message}`,
-                  {
-                    error: streamError
-                  }
-                );
+                logError(streamError, logger);
                 res.statusCode = 500;
                 res.end("Internal server error");
               }
@@ -82,18 +75,11 @@ const configurePreviewServer = async function _configurePreviewServer({ server,
       } catch (error) {
         const err = error;
         if (err.code === "ENOENT") {
-          server.config.logger.error(
-            `File not found: ${filePath}. ${err.message}`,
-            {
-              error: err
-            }
-          );
+          logError(err, logger);
           res.statusCode = 404;
           res.end("File not found");
         } else {
-          server.config.logger.error(`Error loading file: ${filePath}.`, {
-            error: err
-          });
+          logError(err, logger);
           res.statusCode = 500;
           res.end("Internal server error");
         }
@@ -105,4 +91,4 @@ const configurePreviewServer = async function _configurePreviewServer({ server,
 };
 
 export { configurePreviewServer };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"configurePreviewServer.js","sources":["../../../plugin/react-static/configurePreviewServer.ts"],"sourcesContent":["import type { PreviewServer } from \"vite\";\nimport type {\n  ResolvedUserOptions,\n  StreamError,\n} from \"../types.js\";\nimport { join } from \"node:path\";\nimport { createReadStream } from \"node:fs\";\nimport { stat } from \"node:fs/promises\";\nimport { pipeline } from \"node:stream/promises\";\nimport { requestInfo } from \"../helpers/requestInfo.js\";\n\nexport type ConfigurePreviewServerProps<Opt extends ResolvedUserOptions> = {\n  server: PreviewServer;\n  userOptions: Opt;\n};\n\nexport type ConfigurePreviewServerFn = <Opt extends ResolvedUserOptions>(\n  props: ConfigurePreviewServerProps<Opt>\n) => Promise<void>;\n\nexport const configurePreviewServer: ConfigurePreviewServerFn =\n  async function _configurePreviewServer({ server, userOptions }) {\n    const staticHostDir = join(\n      userOptions.projectRoot,\n      userOptions.build.outDir,\n      userOptions.build.static\n    );\n    console.log(userOptions.moduleBaseURL, userOptions.moduleBasePath);\n    server.middlewares.use(async (req, res, next) => {\n      if (!req.url) {\n        return next();\n      }\n      const { contentType, filePath, isRscRequest } = requestInfo(\n        req,\n        userOptions,\n        staticHostDir,\n        server.config.logger\n      );\n      // Handle static files including CSS\n      if (filePath && (isRscRequest)) {\n        try {\n          const stats = await stat(filePath);\n          if (stats.isFile()) {\n            res.setHeader(\"Content-Type\", contentType);\n\n            // Create abort controller for the stream\n            const controller = new AbortController();\n            const { signal } = controller;\n\n            // Check if response is still writable before streaming\n            if (!res.writable) {\n              res.statusCode = 499;\n              res.end(\"Client closed request\");\n              return;\n            }\n\n            try {\n              const readStream = createReadStream(filePath);\n              readStream.on(\"error\", () => {\n                if (!res.writable) {\n                  controller.abort();\n                }\n              });\n              await pipeline(readStream, res, { signal });\n            } catch (error) {\n              if (\n                error != null &&\n                typeof error === \"object\" &&\n                \"code\" in error\n              ) {\n                const streamError = error as StreamError;\n                // Handle different error cases\n                if (\n                  streamError.code === \"ERR_STREAM_PREMATURE_CLOSE\" ||\n                  streamError.name === \"AbortError\"\n                ) {\n                  // Client closed the connection\n                  if (res.writable) {\n                    res.statusCode = 499;\n                    res.end(\"Client closed request\");\n                  }\n                } else if (streamError.code === \"ENOENT\") {\n                  // File not found\n                  res.statusCode = 404;\n                  server.config.logger.error(\n                    `File not found: ${filePath}. ${streamError.message}`,\n                    {\n                      error: streamError,\n                    }\n                  );\n                  console.log(\"File not found: \", filePath);\n                  res.end(\"File not found\");\n                } else {\n                  // Server error\n                  server.config.logger.error(\n                    `Error loading file: ${filePath}. ${streamError.message}`,\n                    {\n                      error: streamError,\n                    }\n                  );\n                  res.statusCode = 500;\n                  res.end(\"Internal server error\");\n                }\n              }\n              return;\n            }\n            return;\n          }\n        } catch (error) {\n          const err = error as Error;\n          // Handle file system errors\n          if ((err as NodeJS.ErrnoException).code === \"ENOENT\") {\n            server.config.logger.error(\n              `File not found: ${filePath}. ${err.message}`,\n              {\n                error: err,\n              }\n            );\n            res.statusCode = 404;\n            res.end(\"File not found\");\n          } else {\n            server.config.logger.error(`Error loading file: ${filePath}.`, {\n              error: err,\n            });\n            res.statusCode = 500;\n            res.end(\"Internal server error\");\n          }\n          return;\n        }\n      }\n      next();\n    });\n  };\n"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"configurePreviewServer.js","sources":["../../../plugin/react-static/configurePreviewServer.ts"],"sourcesContent":["import type {  \n  StreamError,  \n} from \"../types.js\";\nimport { join } from \"node:path\";\nimport { createReadStream } from \"node:fs\";\nimport { stat } from \"node:fs/promises\";\nimport { pipeline } from \"node:stream/promises\";\nimport { requestInfo } from \"../helpers/requestInfo.js\";\nimport { logError } from \"../error/logError.js\";\nimport type { ConfigurePreviewServerFn } from \"./types.js\";\n\nexport const configurePreviewServer: ConfigurePreviewServerFn =\n  function _configurePreviewServer({ server, userOptions }) {\n    const staticHostDir = join(\n      userOptions.projectRoot,\n      userOptions.build.outDir,\n      userOptions.build.static\n    );\n\n    server.middlewares.use(async (req, res, next) => {\n      if (!req.url) {\n        return next();\n      }\n      const logger = server.config.customLogger || server.config.logger;\n      const handlerOptions = {\n        ...userOptions,\n        logger,\n      };\n      const { contentType, filePath, isRscRequest } = requestInfo(\n        req,\n        handlerOptions,\n        staticHostDir,  \n      );\n      \n      // Handle static files including CSS\n      if (filePath && (isRscRequest)) {\n        try {\n          const stats = await stat(filePath);\n          if (stats.isFile()) {\n            res.setHeader(\"Content-Type\", contentType);\n\n            // Create abort controller for the stream\n            const controller = new AbortController();\n            const { signal } = controller;\n\n            // Check if response is still writable before streaming\n            if (!res.writable) {\n              res.statusCode = 499;\n              res.end(\"Client closed request\");\n              return;\n            }\n\n            try {\n              const readStream = createReadStream(filePath);\n              readStream.on(\"error\", () => {\n                if (!res.writable) {\n                  controller.abort(\"aborted by preview server\");\n                }\n              });\n              await pipeline(readStream, res, { signal });\n            } catch (error) {\n              if (\n                error != null &&\n                typeof error === \"object\" &&\n                \"code\" in error\n              ) {\n                const streamError = error as StreamError;\n                // Handle different error cases\n                if (\n                  streamError.code === \"ERR_STREAM_PREMATURE_CLOSE\" ||\n                  streamError.name === \"AbortError\"\n                ) {\n                  // Client closed the connection\n                  if (res.writable) {\n                    res.statusCode = 499;\n                    res.end(\"Client closed request\");\n                  }\n                } else if (streamError.code === \"ENOENT\") {\n                  // File not found\n                  res.statusCode = 404;\n                  logError(streamError, logger);\n\n                  res.end(\"File not found\");\n                } else {\n                  // Server error\n                  logError(streamError, logger);\n                  res.statusCode = 500;\n                  res.end(\"Internal server error\");\n                }\n              }\n              return;\n            }\n            return;\n          }\n        } catch (error) {\n          const err = error as Error;\n          // Handle file system errors\n          if ((err as NodeJS.ErrnoException).code === \"ENOENT\") {\n            logError(err, logger);\n            res.statusCode = 404;\n            res.end(\"File not found\");\n          } else {\n            logError(err, logger);\n            res.statusCode = 500;\n            res.end(\"Internal server error\");\n          }\n          return;\n        }\n      }\n      next();\n    });\n  };\n"],"names":[],"mappings":";;;;;;;;;;;;AAWO,MAAM,yBACX,SAAS,uBAAA,CAAwB,EAAE,MAAA,EAAQ,aAAe,EAAA;AACxD,EAAA,MAAM,aAAgB,GAAA,IAAA;AAAA,IACpB,WAAY,CAAA,WAAA;AAAA,IACZ,YAAY,KAAM,CAAA,MAAA;AAAA,IAClB,YAAY,KAAM,CAAA;AAAA,GACpB;AAEA,EAAA,MAAA,CAAO,WAAY,CAAA,GAAA,CAAI,OAAO,GAAA,EAAK,KAAK,IAAS,KAAA;AAC/C,IAAI,IAAA,CAAC,IAAI,GAAK,EAAA;AACZ,MAAA,OAAO,IAAK,EAAA;AAAA;AAEd,IAAA,MAAM,MAAS,GAAA,MAAA,CAAO,MAAO,CAAA,YAAA,IAAgB,OAAO,MAAO,CAAA,MAAA;AAC3D,IAAA,MAAM,cAAiB,GAAA;AAAA,MACrB,GAAG,WAAA;AAAA,MACH;AAAA,KACF;AACA,IAAA,MAAM,EAAE,WAAA,EAAa,QAAU,EAAA,YAAA,EAAiB,GAAA,WAAA;AAAA,MAC9C,GAAA;AAAA,MACA,cAAA;AAAA,MACA;AAAA,KACF;AAGA,IAAA,IAAI,YAAa,YAAe,EAAA;AAC9B,MAAI,IAAA;AACF,QAAM,MAAA,KAAA,GAAQ,MAAM,IAAA,CAAK,QAAQ,CAAA;AACjC,QAAI,IAAA,KAAA,CAAM,QAAU,EAAA;AAClB,UAAI,GAAA,CAAA,SAAA,CAAU,gBAAgB,WAAW,CAAA;AAGzC,UAAM,MAAA,UAAA,GAAa,IAAI,eAAgB,EAAA;AACvC,UAAM,MAAA,EAAE,QAAW,GAAA,UAAA;AAGnB,UAAI,IAAA,CAAC,IAAI,QAAU,EAAA;AACjB,YAAA,GAAA,CAAI,UAAa,GAAA,GAAA;AACjB,YAAA,GAAA,CAAI,IAAI,uBAAuB,CAAA;AAC/B,YAAA;AAAA;AAGF,UAAI,IAAA;AACF,YAAM,MAAA,UAAA,GAAa,iBAAiB,QAAQ,CAAA;AAC5C,YAAW,UAAA,CAAA,EAAA,CAAG,SAAS,MAAM;AAC3B,cAAI,IAAA,CAAC,IAAI,QAAU,EAAA;AACjB,gBAAA,UAAA,CAAW,MAAM,2BAA2B,CAAA;AAAA;AAC9C,aACD,CAAA;AACD,YAAA,MAAM,QAAS,CAAA,UAAA,EAAY,GAAK,EAAA,EAAE,QAAQ,CAAA;AAAA,mBACnC,KAAO,EAAA;AACd,YAAA,IACE,SAAS,IACT,IAAA,OAAO,KAAU,KAAA,QAAA,IACjB,UAAU,KACV,EAAA;AACA,cAAA,MAAM,WAAc,GAAA,KAAA;AAEpB,cAAA,IACE,WAAY,CAAA,IAAA,KAAS,4BACrB,IAAA,WAAA,CAAY,SAAS,YACrB,EAAA;AAEA,gBAAA,IAAI,IAAI,QAAU,EAAA;AAChB,kBAAA,GAAA,CAAI,UAAa,GAAA,GAAA;AACjB,kBAAA,GAAA,CAAI,IAAI,uBAAuB,CAAA;AAAA;AACjC,eACF,MAAA,IAAW,WAAY,CAAA,IAAA,KAAS,QAAU,EAAA;AAExC,gBAAA,GAAA,CAAI,UAAa,GAAA,GAAA;AACjB,gBAAA,QAAA,CAAS,aAAa,MAAM,CAAA;AAE5B,gBAAA,GAAA,CAAI,IAAI,gBAAgB,CAAA;AAAA,eACnB,MAAA;AAEL,gBAAA,QAAA,CAAS,aAAa,MAAM,CAAA;AAC5B,gBAAA,GAAA,CAAI,UAAa,GAAA,GAAA;AACjB,gBAAA,GAAA,CAAI,IAAI,uBAAuB,CAAA;AAAA;AACjC;AAEF,YAAA;AAAA;AAEF,UAAA;AAAA;AACF,eACO,KAAO,EAAA;AACd,QAAA,MAAM,GAAM,GAAA,KAAA;AAEZ,QAAK,IAAA,GAAA,CAA8B,SAAS,QAAU,EAAA;AACpD,UAAA,QAAA,CAAS,KAAK,MAAM,CAAA;AACpB,UAAA,GAAA,CAAI,UAAa,GAAA,GAAA;AACjB,UAAA,GAAA,CAAI,IAAI,gBAAgB,CAAA;AAAA,SACnB,MAAA;AACL,UAAA,QAAA,CAAS,KAAK,MAAM,CAAA;AACpB,UAAA,GAAA,CAAI,UAAa,GAAA,GAAA;AACjB,UAAA,GAAA,CAAI,IAAI,uBAAuB,CAAA;AAAA;AAEjC,QAAA;AAAA;AACF;AAEF,IAAK,IAAA,EAAA;AAAA,GACN,CAAA;AACH;;;;"}

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

@@ -0,0 +1,2 @@
+export declare function createBuildLoader(): (_id: string) => Promise<never>;
+//# sourceMappingURL=createBuildLoader.client.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createBuildLoader.client.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/createBuildLoader.client.ts"],"names":[],"mappings":"AAAA,wBAAgB,iBAAiB,KAGK,KAAK,MAAM,oBAGhD"}

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

@@ -0,0 +1,7 @@
+export function createBuildLoader() {
+    // In client-static, the RSC worker handles all module loading
+    // The main thread doesn't need to load modules directly
+    return async function buildLoader(_id) {
+        throw new Error("createBuildLoader is called from the client, but it is only available on the server.");
+    };
+}

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

@@ -1,20 +1,4 @@
-import type { BuildModuleLoader, ResolvedUserConfig, ResolvedUserOptions } from "../../server.js";
-import type { Manifest } from "vite";
-import type { OutputBundle } from "rollup";
-export type CreateBuildLoaderFn = (props: {
-    userConfig: ResolvedUserConfig;
-    userOptions: ResolvedUserOptions;
-    serverManifest: Manifest;
-    clientManifest: Manifest;
-    staticManifest: Manifest;
-}, bundle: OutputBundle) => BuildModuleLoader;
-/**
- * Creates a loader function for handling module resolution during build.
- *
- * The loader handles the following strategy:
- *  - For client components: Use client manifest and client.browser.js
- *  - For server components: Use server manifest and server.js
- *  - For static assets: Use static manifest
- */
-export declare const createBuildLoader: CreateBuildLoaderFn;
+import type { CreateBuildLoaderFn } from "./types.js";
+declare const createBuildLoader: CreateBuildLoaderFn;
+export { createBuildLoader };
 //# sourceMappingURL=createBuildLoader.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"createBuildLoader.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/createBuildLoader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,MAAM,CAAC;AAErC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAM3C,MAAM,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE;IACxC,UAAU,EAAE,kBAAkB,CAAC;IAC/B,WAAW,EAAE,mBAAmB,CAAC;IACjC,cAAc,EAAE,QAAQ,CAAC;IACzB,cAAc,EAAE,QAAQ,CAAC;IACzB,cAAc,EAAE,QAAQ,CAAC;CAC1B,EAAE,MAAM,EAAE,YAAY,KAAK,iBAAiB,CAAC;AAE9C;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,mBA+Q/B,CAAA"}
+{"version":3,"file":"createBuildLoader.d.ts","sourceRoot":"","sources":["../../../plugin/react-static/createBuildLoader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAKtD,QAAA,MAAQ,iBAAiB,qBAEuB,CAAC;AAEjD,OAAO,EAAE,iBAAiB,EAAE,CAAC"}