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

package/dist/plugin/stream/createHtmlStream.server.js

@@ -0,0 +1,224 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { PassThrough } from 'node:stream';
+import { createLogger } from 'vite';
+import { createSerializableHandlerOptions } from '../helpers/createSerializableHandlerOptions.js';
+import { toError } from '../error/toError.js';
+import { serializeError } from '../error/serializeError.js';
+import { createMessageChannels } from './createMessageChannels.js';
+
+const createHtmlStream = function _createHtmlStream(options) {
+  const {
+    route,
+    id = route,
+    rscStream,
+    htmlWorker,
+    verbose = false,
+    logger = createLogger(),
+    onError,
+    panicThreshold
+  } = options;
+  if (verbose) {
+    logger.info(
+      `[createHtmlStream.server:${route}] Creating HTML stream with MessagePort`
+    );
+  }
+  if (!htmlWorker) {
+    throw new Error("HTML worker is required for server-side HTML streaming");
+  }
+  const { dataPort1, dataPort2, controlPort1, controlPort2 } = createMessageChannels();
+  const htmlStream = new PassThrough();
+  let isStreamEnded = false;
+  let chunkCount = 0;
+  let isHtmlStreamReady = true;
+  let pendingRscChunks = [];
+  const processPendingRscChunks = () => {
+    if (verbose && pendingRscChunks.length > 0) {
+      logger.info(
+        `[createHtmlStream.server:${route}] Processing ${pendingRscChunks.length} pending RSC chunks`
+      );
+    }
+    while (pendingRscChunks.length > 0 && isHtmlStreamReady && !isStreamEnded) {
+      const chunk = pendingRscChunks.shift();
+      try {
+        dataPort1.postMessage(chunk);
+        chunkCount++;
+        if (verbose) {
+          logger.info(
+            `[createHtmlStream.server:${route}] Processed pending RSC chunk ${chunkCount}`
+          );
+        }
+      } catch (error) {
+        pendingRscChunks.unshift(chunk);
+        if (verbose) {
+          logger.info(
+            `[createHtmlStream.server:${route}] Still backpressure, stopping processing`
+          );
+        }
+        break;
+      }
+    }
+  };
+  const sendChunk = (chunk) => {
+    if (!isStreamEnded && isHtmlStreamReady) {
+      try {
+        dataPort1.postMessage(chunk);
+        chunkCount++;
+        if (verbose) {
+          logger.info(
+            `[createHtmlStream.server:${route}] Sent chunk ${chunkCount}`
+          );
+        }
+      } catch (error) {
+        if (verbose) {
+          logger.info(
+            `[createHtmlStream.server:${route}] MessagePort backpressure detected, RSC stream will naturally slow down`
+          );
+        }
+      }
+    } else if (!isStreamEnded) {
+      pendingRscChunks.push(chunk);
+      if (verbose) {
+        logger.info(
+          `[createHtmlStream.server:${route}] HTML stream backpressured, buffering RSC chunk (${pendingRscChunks.length} pending)`
+        );
+      }
+    }
+  };
+  const dataMessageHandler = (event) => {
+    const data = event;
+    if (data === void 0) {
+      return;
+    }
+    if (data === null) {
+      if (verbose) {
+        logger.info(`[createHtmlStream.server:${route}] HTML stream ended by worker`);
+      }
+      htmlStream.end();
+      cleanup();
+      htmlWorker.postMessage({ type: "CLEANUP", id, route });
+    } else {
+      if (verbose) {
+        logger.info(`[createHtmlStream.server:${route}] Writing HTML chunk: ${data.length} bytes`);
+      }
+      if (htmlStream.destroyed || htmlStream.writableEnded) {
+        if (verbose) {
+          logger.info(`[createHtmlStream.server:${route}] HTML stream already ended, ignoring data chunk`);
+        }
+        return;
+      }
+      const canWrite = htmlStream.write(data);
+      if (!canWrite) {
+        if (verbose) {
+          logger.info(
+            `[createHtmlStream.server:${route}] HTML stream backpressured, pausing worker`
+          );
+        }
+        isHtmlStreamReady = false;
+        controlPort1.postMessage({ type: "PAUSE", id });
+        htmlStream.once("drain", () => {
+          if (verbose) {
+            logger.info(
+              `[createHtmlStream.server:${route}] HTML stream drained, resuming worker`
+            );
+          }
+          isHtmlStreamReady = true;
+          processPendingRscChunks();
+          controlPort1.postMessage({ type: "RESUME", id });
+        });
+      }
+    }
+  };
+  dataPort1.on("message", dataMessageHandler);
+  const controlMessageHandler = (event) => {
+    const message = event;
+    if (!message || typeof message !== "object") {
+      return;
+    }
+    switch (message.type) {
+      case "READY":
+        if (verbose) {
+          logger.info(`[createHtmlStream.server:${route}] HTML worker ready for more data`);
+        }
+        processPendingRscChunks();
+        break;
+      case "END":
+        if (verbose) {
+          logger.info(
+            `[createHtmlStream.server:${route}] Received END message, waiting for null data to confirm completion`
+          );
+        }
+        break;
+      case "ERROR":
+        const error = toError(message.error, message.errorInfo);
+        htmlStream.destroy(error);
+        if (onError) {
+          const isPanic = panicThreshold === "all_errors";
+          onError(error, isPanic);
+        }
+        cleanup();
+        htmlWorker.postMessage({ type: "CLEANUP", id, route });
+        break;
+      case "METRICS":
+        break;
+      case "HTML_RENDER_START":
+        break;
+      case "CLEANUP_COMPLETE":
+        if (verbose) {
+          logger.info(`[createHtmlStream.server:${route}] Worker cleanup completed for route ${message.id}`);
+        }
+        break;
+    }
+  };
+  controlPort1.on("message", controlMessageHandler);
+  htmlWorker.postMessage(
+    {
+      type: "INIT",
+      id: route,
+      dataPort: dataPort2,
+      controlPort: controlPort2,
+      options: createSerializableHandlerOptions(options)
+    },
+    [dataPort2, controlPort2]
+  );
+  if (rscStream) {
+    if (verbose) {
+      logger.info(
+        `[createHtmlStream.server:${route}] Piping RSC stream to HTML worker`
+      );
+    }
+    rscStream.on("data", (chunk) => {
+      sendChunk(chunk);
+    });
+    rscStream.on("end", () => {
+      isStreamEnded = true;
+    });
+    rscStream.on("error", (error) => {
+      const serializedError = serializeError(error);
+      controlPort1.postMessage({ type: "ERROR", error: serializedError });
+      dataPort1.postMessage({ error: serializedError });
+    });
+  }
+  const cleanup = () => {
+    try {
+      dataPort1.removeListener("message", dataMessageHandler);
+      controlPort1.removeListener("message", controlMessageHandler);
+    } catch (error) {
+    }
+  };
+  return {
+    pipe: (destination) => htmlStream.pipe(destination),
+    abort: () => {
+      controlPort1.postMessage({ type: "ABORT", reason: "Stream aborted" });
+      htmlStream.end();
+      cleanup();
+      htmlWorker.postMessage({ type: "CLEANUP", id, route });
+    }
+  };
+};
+
+export { createHtmlStream };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"createHtmlStream.server.js","sources":["../../../plugin/stream/createHtmlStream.server.ts"],"sourcesContent":["import { PassThrough } from \"node:stream\";\nimport { createLogger } from \"vite\";\nimport type { CreateHtmlStreamFn } from \"./createHtmlStream.types.js\";\nimport { createSerializableHandlerOptions } from \"../helpers/createSerializableHandlerOptions.js\";\nimport { toError } from \"../error/toError.js\";\nimport { serializeError } from \"../error/serializeError.js\";\nimport { createMessageChannels } from \"./createMessageChannels.js\";\n/**\n * Creates an HTML stream using a MessagePort for direct communication with the HTML worker\n */\nexport const createHtmlStream: CreateHtmlStreamFn = function _createHtmlStream(\n  options\n) {\n  const {\n    route,\n    id = route,\n    rscStream,\n    htmlWorker,\n    verbose = false,\n    logger = createLogger(),\n    onError,\n    panicThreshold,\n  } = options;\n\n  if (verbose) {\n    logger.info(\n      `[createHtmlStream.server:${route}] Creating HTML stream with MessagePort`\n    );\n  }\n\n  if (!htmlWorker) {\n    throw new Error(\"HTML worker is required for server-side HTML streaming\");\n  }\n\n  // Create two separate MessagePorts for clean separation of concerns\n  const { dataPort1, dataPort2, controlPort1, controlPort2 } = createMessageChannels();\n\n  // Create the HTML output stream\n  const htmlStream = new PassThrough();\n\n  // Flow control state for HTML output stream backpressure handling\n  let isStreamEnded = false;\n  let chunkCount = 0; // Track number of chunks sent\n  let isHtmlStreamReady = true; // Track if HTML stream can accept more data\n  let pendingRscChunks: any[] = []; // Buffer for RSC chunks when HTML stream is backpressured\n  // No need to track END message state - rely on null data message for completion\n\n  // Function to process pending RSC chunks when HTML stream becomes ready\n  const processPendingRscChunks = () => {\n    if (verbose && pendingRscChunks.length > 0) {\n      logger.info(\n        `[createHtmlStream.server:${route}] Processing ${pendingRscChunks.length} pending RSC chunks`\n      );\n    }\n\n    while (pendingRscChunks.length > 0 && isHtmlStreamReady && !isStreamEnded) {\n      const chunk = pendingRscChunks.shift()!;\n      try {\n        dataPort1.postMessage(chunk);\n        chunkCount++;\n        if (verbose) {\n          logger.info(\n            `[createHtmlStream.server:${route}] Processed pending RSC chunk ${chunkCount}`\n          );\n        }\n      } catch (error) {\n        // Still backpressure, put chunk back and stop\n        pendingRscChunks.unshift(chunk);\n        if (verbose) {\n          logger.info(\n            `[createHtmlStream.server:${route}] Still backpressure, stopping processing`\n          );\n        }\n        break;\n      }\n    }\n  };\n\n  // Function to send a chunk to the worker\n  // Check if HTML stream is ready before sending RSC chunks\n  const sendChunk = (chunk: any) => {\n    if (!isStreamEnded && isHtmlStreamReady) {\n      try {\n        dataPort1.postMessage(chunk);\n        chunkCount++;\n        if (verbose) {\n          logger.info(\n            `[createHtmlStream.server:${route}] Sent chunk ${chunkCount}`\n          );\n        }\n      } catch (error) {\n        // MessagePort error - this will naturally backpressure the RSC stream\n        if (verbose) {\n          logger.info(\n            `[createHtmlStream.server:${route}] MessagePort backpressure detected, RSC stream will naturally slow down`\n          );\n        }\n      }\n    } else if (!isStreamEnded) {\n      // HTML stream is backpressured, buffer this RSC chunk\n      pendingRscChunks.push(chunk);\n      if (verbose) {\n        logger.info(\n          `[createHtmlStream.server:${route}] HTML stream backpressured, buffering RSC chunk (${pendingRscChunks.length} pending)`\n        );\n      }\n    }\n  };\n\n  // Data port - receives HTML data from worker\n  const dataMessageHandler = (event: any) => {\n    if (verbose) {\n    }\n    const data = event; // MessagePort events contain the data directly\n    \n    if (data === undefined) {\n\n      return; // Ignore undefined messages\n    }\n\n    if (data === null) {\n      // End of stream\n      if (verbose) {\n        logger.info(`[createHtmlStream.server:${route}] HTML stream ended by worker`);\n      }\n      htmlStream.end();\n\n      // Clean up listeners and close ports when stream ends naturally\n      cleanup();\n\n      // Send cleanup message to worker to reset its internal state\n      // This prevents race conditions between page renders\n      htmlWorker.postMessage({ type: \"CLEANUP\", id: id, route: route });\n    } else {\n      // Raw HTML data from worker - write to stream\n      if (verbose) {\n        logger.info(`[createHtmlStream.server:${route}] Writing HTML chunk: ${data.length} bytes`);\n      }\n      \n      // Check if the HTML stream is still writable before attempting to write\n      if (htmlStream.destroyed || htmlStream.writableEnded) {\n        if (verbose) {\n          logger.info(`[createHtmlStream.server:${route}] HTML stream already ended, ignoring data chunk`);\n        }\n        return;\n      }\n\n      // Data received - stream is still active\n\n      // Check if the HTML stream can accept more data (backpressure handling)\n      const canWrite = htmlStream.write(data);\n\n      if (!canWrite) {\n        // HTML stream is backpressured, pause the worker\n        if (verbose) {\n          logger.info(\n            `[createHtmlStream.server:${route}] HTML stream backpressured, pausing worker`\n          );\n        }\n        isHtmlStreamReady = false;\n        \n        // Tell the worker to pause sending more data\n        controlPort1.postMessage({ type: \"PAUSE\", id: id });\n\n        // Listen for drain event to resume\n        htmlStream.once(\"drain\", () => {\n          if (verbose) {\n            logger.info(\n              `[createHtmlStream.server:${route}] HTML stream drained, resuming worker`\n            );\n          }\n          isHtmlStreamReady = true;\n          // Process any pending RSC chunks first\n          processPendingRscChunks();\n          // Tell worker it can resume sending data\n          controlPort1.postMessage({ type: \"RESUME\", id: id });\n        });\n      }\n      \n    }\n  };\n  \n  dataPort1.on('message', dataMessageHandler);\n\n  // Control port\n  const controlMessageHandler = (event: any) => {\n  \n    const message = event; // MessagePort events contain the data directly\n    \n    if (!message || typeof message !== 'object') {\n     \n      return; // Ignore invalid messages\n    }\n    \n\n    switch (message.type) {\n      case \"READY\":\n        // Flow control: HTML worker is ready for more data\n        if (verbose) {\n          logger.info(`[createHtmlStream.server:${route}] HTML worker ready for more data`);\n        }\n        // Process any pending RSC chunks that were buffered due to backpressure\n        processPendingRscChunks();\n        break;\n      case \"END\":\n        // Don't end the stream yet - wait for the null data message\n        // The worker will send null through the data port when actually done\n        if (verbose) {\n          logger.info(\n            `[createHtmlStream.server:${route}] Received END message, waiting for null data to confirm completion`\n          );\n        }\n        break;\n      case \"ERROR\":\n        const error = toError(message.error, message.errorInfo);\n        htmlStream.destroy(error);\n\n        // Call the error callback if provided\n        if (onError) {\n          const isPanic = panicThreshold === \"all_errors\";\n          onError(error, isPanic);\n        }\n\n        // Clean up listeners and close ports when stream is destroyed due to error\n        cleanup();\n\n        // Send cleanup message to worker to reset its internal state\n        // This prevents race conditions between page renders\n        htmlWorker.postMessage({ type: \"CLEANUP\", id: id, route: route });\n        break;\n      case \"METRICS\":\n        break;\n      case \"HTML_RENDER_START\":\n        break;\n      case \"CLEANUP_COMPLETE\":\n        // Worker has completed cleanup - this is just a confirmation\n        if (verbose) {\n          logger.info(`[createHtmlStream.server:${route}] Worker cleanup completed for route ${message.id}`);\n        }\n        break;\n      default:\n        break;\n    }\n  };\n  \n  controlPort1.on('message', controlMessageHandler);\n\n  // Send the HTML stream request to the worker with both MessagePorts\n  htmlWorker.postMessage(\n    {\n      type: \"INIT\",\n      id: route,\n      dataPort: dataPort2,\n      controlPort: controlPort2,\n      options: createSerializableHandlerOptions(options),\n    },\n    [dataPort2, controlPort2] as any\n  ); // Transfer both ports to the worker\n\n  // If we have an RSC stream, pipe it to the worker via dataPort\n  if (rscStream) {\n    if (verbose) {\n      logger.info(\n        `[createHtmlStream.server:${route}] Piping RSC stream to HTML worker`\n      );\n    }\n\n    // Pipe the RSC stream data directly to the worker via dataPort\n    rscStream.on(\"data\", (chunk) => {\n      sendChunk(chunk);\n    });\n\n    rscStream.on(\"end\", () => {\n      isStreamEnded = true;\n    });\n\n    rscStream.on(\"error\", (error) => {\n      const serializedError = serializeError(error);\n      controlPort1.postMessage({ type: \"ERROR\", error: serializedError });\n      dataPort1.postMessage({ error: serializedError });\n    });\n  }\n\n  // Unified cleanup function that handles listeners only\n  // Let React manage the MessagePort lifecycle to prevent \"Connection closed\" errors\n  const cleanup = () => {\n    try {\n      dataPort1.removeListener('message', dataMessageHandler);\n      controlPort1.removeListener('message', controlMessageHandler);\n      // Don't close ports - let React finish consuming and close naturally\n    } catch (error) {\n      // Ignore cleanup errors\n    }\n  };\n\n  // Note: Process-level cleanup is handled by worker shutdown protocol\n\n  return {\n    pipe: (destination: any) => htmlStream.pipe(destination),\n      abort: () => {\n    controlPort1.postMessage({ type: \"ABORT\", reason: \"Stream aborted\" });\n    htmlStream.end();\n\n    // Use unified cleanup\n    cleanup();\n\n    // Send cleanup message to worker to reset its internal state\n    // This prevents race conditions between page renders\n    htmlWorker.postMessage({ type: \"CLEANUP\", id: id, route: route });\n  },\n  };\n};\n"],"names":[],"mappings":"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"}

package/dist/plugin/stream/createHtmlStream.types.d.ts

@@ -0,0 +1,43 @@
+import type { Manifest } from "vite";
+import type { CreateHandlerOptions, CssContent, PanicThreshold, ResolvedUserOptions } from "../types.js";
+import type { PassThrough, Readable } from "node:stream";
+/**
+ * HTML Stream Options - for client-rendered pipeable React
+ * HTML = what gets sent to the browser (client-rendered pipeable React)
+ */
+export type CreateHtmlStreamOptions = Pick<CreateHandlerOptions<ResolvedUserOptions>, "moduleRootPath" | "moduleBasePath" | "moduleBaseURL" | "route" | "clientPipeableStreamOptions" | "projectRoot" | "verbose" | "logger" | "htmlWorker" | "id" | "children"> & {
+    worker?: any;
+    rscStream?: PassThrough | Readable;
+    url?: string;
+    cssFiles?: Map<string, CssContent>;
+    globalCss?: Map<string, CssContent>;
+    manifest?: Manifest;
+    panicThreshold?: PanicThreshold;
+    pagePath?: string;
+    propsPath?: string;
+    rootPath?: string;
+    htmlPath?: string;
+    pageExportName?: string;
+    propsExportName?: string;
+    rootExportName?: string;
+    htmlExportName?: string;
+    moduleBase?: string;
+    publicOrigin?: string;
+    rscTimeout?: number;
+    htmlTimeout?: number;
+    fileWriteTimeout?: number;
+    workerShutdownTimeout?: number;
+    css?: CreateHandlerOptions["css"];
+    build?: CreateHandlerOptions["build"];
+    children?: React.ReactNode;
+    onError?: (error: Error, isPanic: boolean) => void;
+};
+/**
+ * HTML Stream Function - creates client-rendered pipeable React
+ * HTML = what gets sent to the browser
+ */
+export type CreateHtmlStreamFn = <Opt extends CreateHtmlStreamOptions = CreateHtmlStreamOptions>(options: Opt) => {
+    abort: (reason?: unknown) => void;
+    pipe: <Writable extends NodeJS.WritableStream>(destination: Writable) => Writable;
+};
+//# sourceMappingURL=createHtmlStream.types.d.ts.map

package/dist/plugin/stream/createHtmlStream.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createHtmlStream.types.d.ts","sourceRoot":"","sources":["../../../plugin/stream/createHtmlStream.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,MAAM,CAAC;AACrC,OAAO,KAAK,EAAE,oBAAoB,EAAE,UAAU,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACzG,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEzD;;;GAGG;AACH,MAAM,MAAM,uBAAuB,GAAG,IAAI,CACxC,oBAAoB,CAAC,mBAAmB,CAAC,EACvC,gBAAgB,GAChB,gBAAgB,GAChB,eAAe,GACf,OAAO,GACP,6BAA6B,GAC7B,aAAa,GACb,SAAS,GACT,QAAQ,GACR,YAAY,GACZ,IAAI,GACJ,UAAU,CACb,GAAG;IACF,MAAM,CAAC,EAAE,GAAG,CAAC;IAEb,SAAS,CAAC,EAAE,WAAW,GAAG,QAAQ,CAAC;IAEnC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACnC,SAAS,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IACpC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,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,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,GAAG,CAAC,EAAE,oBAAoB,CAAC,KAAK,CAAC,CAAC;IAClC,KAAK,CAAC,EAAE,oBAAoB,CAAC,OAAO,CAAC,CAAC;IACtC,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;CACpD,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAC/B,GAAG,SAAS,uBAAuB,GAAG,uBAAuB,EAE7D,OAAO,EAAE,GAAG,KACT;IACH,KAAK,EAAE,CAAC,MAAM,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IAClC,IAAI,EAAE,CAAC,QAAQ,SAAS,MAAM,CAAC,cAAc,EAAE,WAAW,EAAE,QAAQ,KAAK,QAAQ,CAAC;CACnF,CAAC"}

package/dist/plugin/stream/createHtmlStream.types.js

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

package/dist/plugin/stream/createMainThreadHandlers.d.ts

@@ -0,0 +1,11 @@
+import type { CreateHandlerOptions } from "../types.js";
+export declare function createMainThreadHandlers(handlerOptions: CreateHandlerOptions, onError?: (error: Error, isPanic: boolean) => void): {
+    onError: (_id: string, error: unknown, context?: {
+        route?: string;
+        context?: string;
+    }) => void;
+    onData: (_id: string, _data: Uint8Array) => void;
+    onEnd: (_id: string) => void;
+    onPostpone: (_id: string, _reason: string) => void;
+};
+//# sourceMappingURL=createMainThreadHandlers.d.ts.map

package/dist/plugin/stream/createMainThreadHandlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMainThreadHandlers.d.ts","sourceRoot":"","sources":["../../../plugin/stream/createMainThreadHandlers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAGxD,wBAAgB,wBAAwB,CACtC,cAAc,EAAE,oBAAoB,EACpC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI;mBAGjC,MAAM,SAAS,OAAO,YAAY;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;kBAyBvE,MAAM,SAAS,UAAU;iBAG1B,MAAM;sBAGD,MAAM,WAAW,MAAM;EAI5C"}

package/dist/plugin/stream/createMainThreadHandlers.js

@@ -0,0 +1,32 @@
+import { handleError } from "../error/handleError.js";
+export function createMainThreadHandlers(handlerOptions, onError) {
+    return {
+        onError: (_id, error, context) => {
+            if (handlerOptions.verbose) {
+                handlerOptions.logger?.info(`[createMainThreadHandlers] onError called for route ${handlerOptions.route}: ${error}`);
+            }
+            const originalError = error instanceof Error ? error : new Error(String(error ?? "Unknown error"));
+            const panicError = handleError({
+                error: originalError,
+                critical: false,
+                logger: handlerOptions.logger,
+                panicThreshold: handlerOptions.panicThreshold,
+                context: `${context?.context || "Unknown"} for route ${handlerOptions.route}`,
+            });
+            if (handlerOptions.verbose) {
+                handlerOptions.logger?.info(`[createMainThreadHandlers] Calling onError callback for route ${handlerOptions.route} with panicError: ${!!panicError}`);
+            }
+            // Call the callback with the error and panic status
+            onError?.(panicError || originalError, !!panicError);
+        },
+        onData: (_id, _data) => {
+            // No-op for main thread
+        },
+        onEnd: (_id) => {
+            // No-op for main thread
+        },
+        onPostpone: (_id, _reason) => {
+            // No-op for main thread
+        },
+    };
+}

package/dist/plugin/stream/createMessageChannels.d.ts

@@ -0,0 +1,29 @@
+import { MessageChannel } from "node:worker_threads";
+/**
+ * Creates a pair of MessageChannels for two-port communication pattern.
+ *
+ * This is the standard pattern used throughout the codebase for worker communication:
+ * - Data channel: For streaming actual data (RSC chunks, HTML content, etc.)
+ * - Control channel: For control messages (completion signals, errors, metrics, etc.)
+ *
+ * @returns Object containing both channels with consistent naming
+ */
+export declare function createMessageChannels(): {
+    dataChannel: MessageChannel;
+    controlChannel: MessageChannel;
+    dataPort1: import("worker_threads").MessagePort;
+    dataPort2: import("worker_threads").MessagePort;
+    controlPort1: import("worker_threads").MessagePort;
+    controlPort2: import("worker_threads").MessagePort;
+};
+/**
+ * Creates transfer list for MessagePort communication.
+ *
+ * Used when sending ports through postMessage with transferable objects.
+ *
+ * @param port1 - First port to transfer
+ * @param port2 - Second port to transfer
+ * @returns Array suitable for transferList parameter
+ */
+export declare function createTransferList(port1: any, port2: any): any;
+//# sourceMappingURL=createMessageChannels.d.ts.map

package/dist/plugin/stream/createMessageChannels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMessageChannels.d.ts","sourceRoot":"","sources":["../../../plugin/stream/createMessageChannels.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAGrD;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB;;;;;;;EA0BpC;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,GAC9B,GAAG,CAC7B"}

package/dist/plugin/stream/createMessageChannels.js

@@ -0,0 +1,35 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { MessageChannel } from 'node:worker_threads';
+import { setMaxListenersOnPort, unrefPort } from './setMaxListeners.js';
+
+function createMessageChannels() {
+  const dataChannel = new MessageChannel();
+  const controlChannel = new MessageChannel();
+  setMaxListenersOnPort(dataChannel.port1, 500);
+  setMaxListenersOnPort(dataChannel.port2, 500);
+  setMaxListenersOnPort(controlChannel.port1, 500);
+  setMaxListenersOnPort(controlChannel.port2, 500);
+  unrefPort(dataChannel.port1);
+  unrefPort(dataChannel.port2);
+  unrefPort(controlChannel.port1);
+  unrefPort(controlChannel.port2);
+  return {
+    dataChannel,
+    controlChannel,
+    // Convenience destructuring for common usage pattern
+    dataPort1: dataChannel.port1,
+    dataPort2: dataChannel.port2,
+    controlPort1: controlChannel.port1,
+    controlPort2: controlChannel.port2
+  };
+}
+function createTransferList(port1, port2) {
+  return [port1, port2];
+}
+
+export { createMessageChannels, createTransferList };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/plugin/stream/createRenderToPipeableStreamHandler.client.d.ts

@@ -0,0 +1,10 @@
+import type { CreateRenderToPipeableStreamHandlerFn } from "./createRenderToPipeableStreamHandler.types.js";
+/**
+ * Client version of createRenderToPipeableStreamHandler.
+ *
+ * Strategy: Use simple Node.js stream APIs to naturally handle RSC-to-HTML conversion.
+ * This follows the HTML worker pattern exactly - create a custom writable stream
+ * and pipe the React stream directly to it, then provide a proper stream for fileWriter.
+ */
+export declare const createRenderToPipeableStreamHandler: CreateRenderToPipeableStreamHandlerFn<"client">;
+//# sourceMappingURL=createRenderToPipeableStreamHandler.client.d.ts.map

package/dist/plugin/stream/createRenderToPipeableStreamHandler.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createRenderToPipeableStreamHandler.client.d.ts","sourceRoot":"","sources":["../../../plugin/stream/createRenderToPipeableStreamHandler.client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qCAAqC,EAAE,MAAM,gDAAgD,CAAC;AAU5G;;;;;;GAMG;AACH,eAAO,MAAM,mCAAmC,EAAE,qCAAqC,CAAC,QAAQ,CA8M7F,CAAC"}