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

package/dist/plugin/worker/html/html-worker.development.js

@@ -1,28 +1,11 @@
-/**
- * vite-plugin-react-server
- * Copyright (c) Nico Brinkkemper
- * MIT License
- */
-import { messageHandler } from './messageHandler.js';
-import { workerData, parentPort } from 'node:worker_threads';
-
-const verbose = workerData.verbose;
-function developmentMessageHandler(msg) {
-  if (verbose) {
-    if (msg.type === "RSC_CHUNK") {
-      const preview = Buffer.from(msg.chunk).toString("utf-8");
-      console.log(`[html-worker:${msg.type}] ${preview}`);
-    } else {
-      console.log(`[html-worker:${msg.type}] ${JSON.stringify(msg)}`);
-    }
-  }
-  messageHandler(msg);
-}
-parentPort?.on("message", developmentMessageHandler);
+import { parentPort } from "node:worker_threads";
+import { messageHandler } from "./messageHandler.js";
+// Signal ready with environment
 parentPort?.postMessage({
-  type: "READY",
-  id: "html-worker",
-  env: process.env["NODE_ENV"],
-  pid: process.pid
+    type: "READY",
+    id: "worker/html",
+    env: process.env["NODE_ENV"],
+    pid: process.pid,
 });
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+// Handle MessagePort requests for HTML streaming
+parentPort?.on("message", messageHandler);

package/dist/plugin/worker/html/html-worker.js

@@ -1,4 +1,4 @@
-await (process.env['NODE_ENV'] === 'production'
-    ? import('./html-worker.production.js')
-    : import('./html-worker.development.js'));
-export {};
+import { assertNonReactServer } from "../../config/getCondition.js";
+const env = process.env["NODE_ENV"] !== "development" && process.env["NODE_ENV"] !== "test" ? "production" : "development";
+assertNonReactServer();
+await import(`./html-worker.${env}.js`);

package/dist/plugin/worker/html/html-worker.production.js

@@ -1,16 +1,10 @@
-/**
- * vite-plugin-react-server
- * Copyright (c) Nico Brinkkemper
- * MIT License
- */
-import { messageHandler } from './messageHandler.js';
-import { parentPort } from 'node:worker_threads';
-
+import { messageHandler } from "./messageHandler.js";
+import { parentPort } from "node:worker_threads";
+// Signal ready with environment
 parentPort?.on("message", messageHandler);
 parentPort?.postMessage({
-  type: "READY",
-  id: "html-worker",
-  env: process.env["NODE_ENV"],
-  pid: process.pid
+    type: "READY",
+    id: "worker/html",
+    env: process.env["NODE_ENV"],
+    pid: process.pid,
 });
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHRtbC13b3JrZXIucHJvZHVjdGlvbi5qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGx1Z2luL3dvcmtlci9odG1sL2h0bWwtd29ya2VyLnByb2R1Y3Rpb24udHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IG1lc3NhZ2VIYW5kbGVyIH0gZnJvbSBcIi4vbWVzc2FnZUhhbmRsZXIuanNcIjtcbmltcG9ydCB7IHBhcmVudFBvcnQgfSBmcm9tIFwibm9kZTp3b3JrZXJfdGhyZWFkc1wiO1xuaW1wb3J0IHR5cGUgeyBSZWFkeU1lc3NhZ2UgfSBmcm9tIFwiLi4vdHlwZXMuanNcIjtcblxuLy8gU2lnbmFsIHJlYWR5IHdpdGggZW52aXJvbm1lbnRcbnBhcmVudFBvcnQ/Lm9uKFwibWVzc2FnZVwiLCBtZXNzYWdlSGFuZGxlcik7XG5wYXJlbnRQb3J0Py5wb3N0TWVzc2FnZSh7XG4gIHR5cGU6IFwiUkVBRFlcIixcbiAgaWQ6IFwiaHRtbC13b3JrZXJcIixcbiAgZW52OiBwcm9jZXNzLmVudltcIk5PREVfRU5WXCJdLFxuICBwaWQ6IHByb2Nlc3MucGlkLFxufSBzYXRpc2ZpZXMgUmVhZHlNZXNzYWdlKTtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7OztBQUtBLFVBQVksRUFBQSxFQUFBLENBQUcsV0FBVyxjQUFjLENBQUE7QUFDeEMsVUFBQSxFQUFZLFdBQVksQ0FBQTtBQUFBLEVBQ3RCLElBQU0sRUFBQSxPQUFBO0FBQUEsRUFDTixFQUFJLEVBQUEsYUFBQTtBQUFBLEVBQ0osR0FBQSxFQUFLLE9BQVEsQ0FBQSxHQUFBLENBQUksVUFBVSxDQUFBO0FBQUEsRUFDM0IsS0FBSyxPQUFRLENBQUE7QUFDZixDQUF3QixDQUFBIn0=

package/dist/plugin/worker/html/index.d.ts

@@ -1,2 +1,2 @@
-export * from './types.js';
+export * from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/plugin/worker/html/index.js

@@ -3,5 +3,9 @@
  * Copyright (c) Nico Brinkkemper
  * MIT License
  */
-await (process.env["NODE_ENV"] === "production" ? import('./html-worker.production.js') : import('./html-worker.development.js'));
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BsdWdpbi93b3JrZXIvaHRtbC9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJhd2FpdCAoXG4gIHByb2Nlc3MuZW52WydOT0RFX0VOViddID09PSAncHJvZHVjdGlvbicgXG4gICAgPyBpbXBvcnQoJy4vaHRtbC13b3JrZXIucHJvZHVjdGlvbi5qcycpIFxuICAgIDogaW1wb3J0KCcuL2h0bWwtd29ya2VyLmRldmVsb3BtZW50LmpzJylcbik7XG5cbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMuanMnOyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUFBLE9BQ0UsT0FBQSxDQUFRLElBQUksVUFBVSxDQUFBLEtBQU0sZUFDeEIsT0FBTyw2QkFBNkIsQ0FDcEMsR0FBQSxPQUFPLDhCQUE4QixDQUFBLENBQUEifQ==
+import __variableDynamicImportRuntimeHelper from '../../../_virtual/dynamic-import-helper.js';
+import { getNodeEnv } from '../../config/getNodeEnv.js';
+
+const envName = getNodeEnv() === "production" ? "production" : "development";
+await __variableDynamicImportRuntimeHelper((/* #__PURE__ */ Object.assign({})), `./html-worker.${envName}.js`, 2);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BsdWdpbi93b3JrZXIvaHRtbC9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBnZXROb2RlRW52IH0gZnJvbSBcIi4uLy4uL2NvbmZpZy9nZXROb2RlRW52LmpzXCI7XG5cbmNvbnN0IGVudk5hbWUgPSBnZXROb2RlRW52KCkgPT09IFwicHJvZHVjdGlvblwiID8gXCJwcm9kdWN0aW9uXCIgOiBcImRldmVsb3BtZW50XCI7XG5cbmF3YWl0IGltcG9ydChgLi9odG1sLXdvcmtlci4ke2Vudk5hbWV9LmpzYCk7XG5cbmV4cG9ydCAqIGZyb20gXCIuL3R5cGVzLmpzXCI7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7QUFFQSxNQUFNLE9BQVUsR0FBQSxVQUFBLEVBQWlCLEtBQUEsWUFBQSxHQUFlLFlBQWUsR0FBQSxhQUFBO0FBRS9ELE1BQU0sb0NBQStCLGtCQUFBLE1BQUEsQ0FBQSxNQUFBLENBQUEsRUFBQSxDQUFBLEdBQUEsQ0FBQSxjQUFBLEVBQUEsT0FBQSxDQUFBLEdBQUEsQ0FBQSxFQUFBLENBQUEsQ0FBQSJ9

package/dist/plugin/worker/html/messageHandler.d.ts

@@ -1,3 +1,3 @@
-import type { HtmlWorkerInputMessage } from "../html/types.js";
+import type { HtmlWorkerInputMessage } from "./types.js";
 export declare function messageHandler(msg: HtmlWorkerInputMessage): Promise<void>;
 //# sourceMappingURL=messageHandler.d.ts.map

package/dist/plugin/worker/html/messageHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"messageHandler.d.ts","sourceRoot":"","sources":["../../../../plugin/worker/html/messageHandler.tsx"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAkD,MAAM,kBAAkB,CAAC;AAkC/G,wBAAsB,cAAc,CAAC,GAAG,EAAE,sBAAsB,iBAkF/D"}
+{"version":3,"file":"messageHandler.d.ts","sourceRoot":"","sources":["../../../../plugin/worker/html/messageHandler.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAC;AAyBzD,wBAAsB,cAAc,CAAC,GAAG,EAAE,sBAAsB,iBAmT/D"}

package/dist/plugin/worker/html/messageHandler.js

@@ -1,113 +1,300 @@
-/**
- * vite-plugin-react-server
- * Copyright (c) Nico Brinkkemper
- * MIT License
- */
-import { parentPort } from 'node:worker_threads';
-import { createHtmlWorkerRenderState } from './createHtmlWorkerRenderState.js';
-import { toError } from '../../error/toError.js';
-import { serializeError } from '../../error/serializeError.js';
-
-const activeRenders = /* @__PURE__ */ new Map();
-function sendMessage(msg) {
-  if ("error" in msg) {
-    console.trace(msg.error);
-    parentPort?.postMessage({
-      ...msg,
-      error: serializeError(msg.error)
-    });
-  } else {
-    parentPort?.postMessage(msg);
-  }
-}
-function cleanup(id) {
-  const renderState = activeRenders.get(id);
-  if (renderState) {
-    renderState.rscStream.destroy();
-    renderState.htmlTransform?.destroy();
-    activeRenders.delete(id);
-    sendMessage({
-      type: "CLEANUP_COMPLETE",
-      id
-    });
-  }
+import { PassThrough } from "node:stream";
+import { createLogger } from "vite";
+import { parentPort, workerData } from "node:worker_threads";
+import { handleHtmlRender } from "./handleHtmlRender.js";
+import { serializeError } from "../../error/serializeError.js";
+import { serializeErrorInfo } from "../../error/serializeErrorInfo.js";
+import { DEFAULT_CONFIG } from "../../config/defaults.js";
+import { activeStreams, moduleIds } from "./state.js";
+const verbose = Boolean(workerData?.userOptions?.verbose);
+const logger = createLogger(workerData.resolvedConfig?.logLevel ?? "info");
+// Function to clear all global worker state to prevent race conditions
+function clearWorkerState() {
+    // Clear active streams
+    activeStreams.clear();
+    // Clear module IDs
+    moduleIds.clear();
+    // Note: temporaryReferences is a WeakMap, so it will be garbage collected automatically
+    // when the references are no longer held by the main thread
+    if (verbose) {
+        logger.info(`[html-worker] Cleared global worker state`);
+    }
 }
-async function messageHandler(msg) {
-  const { type, id } = msg;
-  try {
-    switch (type) {
-      case "ROUTE_READY": {
-        let renderState = activeRenders.get(id);
-        if (!renderState) {
-          renderState = createHtmlWorkerRenderState(msg, sendMessage);
-          activeRenders.set(id, renderState);
-        } else {
-          throw new Error("Render state already exists");
+export async function messageHandler(msg) {
+    if (msg && msg.type === "INIT") {
+        const { id, dataPort, controlPort, options } = msg;
+        // Reset worker state for new page render to prevent race conditions
+        // This ensures each page render starts with a clean slate
+        clearWorkerState();
+        if (verbose) {
+            logger.info(`[html-worker] Resetting worker state for new page render: ${id}`);
+        }
+        else if (!workerData?.userOptions) {
+            logger.warn(`[html-worker] No user options found for new page render: ${id}`);
+        }
+        if (options == null) {
+            controlPort.postMessage({
+                type: "ERROR",
+                id,
+                error: {
+                    name: "InvalidOptionsError",
+                    message: "Invalid options",
+                },
+            });
+            return;
         }
-        break;
-      }
-      case "RSC_CHUNK": {
-        const renderState = activeRenders.get(id);
-        if (!renderState) {
-          throw new Error(`No render state found for id: ${id}`);
+        // Check if both ports are available
+        if (!dataPort || !controlPort) {
+            return;
         }
         try {
-          renderState.rscStream.write(msg.chunk);
-          sendMessage({
-            type: "CHUNK_PROCESSED",
-            id,
-            success: true
-          });
-        } catch (error) {
-          const err = toError(error);
-          sendMessage({
-            type: "ERROR",
-            id,
-            error: err
-          });
-          cleanup(id);
+            // Create a PassThrough stream to receive RSC data from the main thread
+            const rscStream = new PassThrough();
+            let streamStarted = false;
+            let htmlRenderStarted = false;
+            let isMainThreadReady = true; // Flag to indicate if the main thread is ready for more data
+            let pendingHtmlChunks = []; // Buffer for HTML chunks when main thread is not ready
+            let pendingEndMessage = false; // Track if we have a pending END message
+            let chunksSentCount = 0; // Track number of chunks sent to main thread
+            let chunksReceivedCount = 0; // Track number of chunks confirmed received by main thread
+            // Function to process pending HTML chunks when main thread becomes ready
+            const processPendingHtmlChunks = () => {
+                if (verbose && pendingHtmlChunks.length > 0) {
+                    logger.info(`[html-worker] Processing ${pendingHtmlChunks.length} pending HTML chunks for route: ${id}`);
+                }
+                while (pendingHtmlChunks.length > 0 && isMainThreadReady) {
+                    const chunk = pendingHtmlChunks.shift();
+                    dataPort.postMessage(chunk);
+                    chunksSentCount++;
+                    if (verbose) {
+                        logger.info(`[html-worker] Processed pending HTML chunk ${chunksSentCount} for route: ${id}`);
+                    }
+                }
+                // If all chunks are processed and we have a pending END message, check if we can send it
+                if (pendingHtmlChunks.length === 0 && pendingEndMessage && isMainThreadReady) {
+                    // Only send END if all sent chunks have been confirmed received
+                    if (chunksSentCount === chunksReceivedCount) {
+                        if (verbose) {
+                            logger.info(`[html-worker] Sending pending END message for route: ${id} (all ${chunksSentCount} chunks confirmed received)`);
+                        }
+                        pendingEndMessage = false;
+                        controlPort.postMessage({ type: "END", id });
+                    }
+                    else {
+                        if (verbose) {
+                            logger.info(`[html-worker] Waiting to send END message for route: ${id} (${chunksReceivedCount}/${chunksSentCount} chunks confirmed received)`);
+                        }
+                    }
+                }
+            };
+            // Set up the HTML render process once when we receive the first chunk
+            const startHtmlRender = () => {
+                if (htmlRenderStarted)
+                    return;
+                htmlRenderStarted = true;
+                if (verbose)
+                    logger.info(`[html-worker] Starting HTML render process for route: ${id}`);
+                // Start the HTML render process
+                handleHtmlRender({
+                    id,
+                    route: options.route,
+                    rscStream,
+                    projectRoot: options?.projectRoot ??
+                        workerData?.userOptions?.projectRoot ??
+                        process.cwd(),
+                    moduleRootPath: options?.moduleRootPath ??
+                        workerData?.userOptions?.moduleRootPath,
+                    moduleBasePath: options?.moduleBasePath ??
+                        workerData?.userOptions?.moduleBasePath ??
+                        DEFAULT_CONFIG.MODULE_BASE_PATH,
+                    moduleBaseURL: options?.moduleBaseURL ??
+                        workerData?.userOptions?.moduleBaseURL ??
+                        DEFAULT_CONFIG.MODULE_BASE_URL,
+                    htmlTimeout: options?.htmlTimeout ??
+                        workerData?.userOptions?.htmlTimeout ??
+                        DEFAULT_CONFIG.HTML_TIMEOUT,
+                    clientPipeableStreamOptions: options?.clientPipeableStreamOptions ??
+                        workerData?.userOptions?.clientPipeableStreamOptions ??
+                        {},
+                    logger,
+                    verbose,
+                }, {
+                    onHtmlRender: (id) => {
+                        controlPort.postMessage({ type: "HTML_RENDER_START", id });
+                    },
+                    onError: (id, error, errorInfo) => {
+                        controlPort.postMessage({
+                            type: "ERROR",
+                            id,
+                            error: serializeError(error),
+                            errorInfo: serializeErrorInfo(errorInfo),
+                        });
+                    },
+                    onEnd: (id) => {
+                        // Follow the same pattern as RSC worker: send null to data port, then END to control port
+                        if (verbose) {
+                            logger.info(`[html-worker] React stream ended for route: ${id}, signaling end of data stream`);
+                        }
+                        // Signal end of data stream via data port (same as RSC worker)
+                        dataPort.postMessage(null);
+                        // Send END control message
+                        if (verbose) {
+                            logger.info(`[html-worker] Sending END control message for route: ${id}`);
+                        }
+                        controlPort.postMessage({ type: "END", id });
+                    },
+                    onShellError: (id, error) => {
+                        controlPort.postMessage({
+                            type: "SHELL_ERROR",
+                            id,
+                            error: serializeError(error),
+                        });
+                    },
+                    onData: (_id, data) => {
+                        // Send HTML data via dataPort (raw data, no type wrapper)
+                        // But only if the main thread is ready to receive it
+                        if (isMainThreadReady) {
+                            dataPort.postMessage(data);
+                            chunksSentCount++;
+                            if (verbose) {
+                                logger.info(`[html-worker] Sent HTML chunk ${chunksSentCount} for route: ${id}`);
+                            }
+                        }
+                        else {
+                            // Main thread is backpressured, buffer this data
+                            pendingHtmlChunks.push(data);
+                            if (verbose) {
+                                logger.info(`[html-worker] Main thread backpressured, buffering HTML chunk for route: ${id}`);
+                            }
+                        }
+                    },
+                    onMetrics: (id, metrics) => {
+                        controlPort.postMessage({ type: "METRICS", id, metrics });
+                    },
+                    onHmrAccept: () => {
+                        // HMR not needed for server-side rendering
+                    },
+                    onHmrUpdate: () => {
+                        // HMR not needed for server-side rendering
+                    },
+                    onCleanup: () => {
+                        // Don't close ports - let React handle cleanup to prevent "Connection closed" errors
+                        // Worker termination will handle port cleanup
+                    },
+                });
+            };
+            // Set up control port message handler for backpressure control
+            controlPort.onmessage = (event) => {
+                const message = event.data;
+                if (verbose) {
+                    logger.info(`[html-worker] Received control message: ${message.type} for route: ${id}`);
+                }
+                switch (message.type) {
+                    case 'PAUSE':
+                        // Main thread is backpressured, pause sending data
+                        if (verbose) {
+                            logger.info(`[html-worker] Main thread backpressured, pausing HTML output for route: ${id}`);
+                        }
+                        isMainThreadReady = false;
+                        break;
+                    case 'RESUME':
+                        // Main thread is ready to receive more HTML data
+                        chunksReceivedCount++;
+                        if (verbose) {
+                            logger.info(`[html-worker] Main thread ready, resuming HTML output for route: ${id} (chunks received: ${chunksReceivedCount})`);
+                        }
+                        isMainThreadReady = true;
+                        processPendingHtmlChunks();
+                        break;
+                    case 'ABORT':
+                        // Stream was aborted
+                        if (verbose) {
+                            logger.info(`[html-worker] Stream aborted for route: ${id}`);
+                        }
+                        // Clean up and stop processing
+                        rscStream.destroy(new Error('Stream aborted'));
+                        break;
+                    default:
+                        // Other control messages are handled by the HTML render handlers
+                        break;
+                }
+            };
+            // Then set the new event listener
+            dataPort.onmessage = (event) => {
+                const data = event.data;
+                if (verbose) {
+                    logger.info(`[html-worker] Received data on dataPort for route: ${id}, data: ${data == null ? 'null/undefined (end)' : `chunk of size ${data?.length || 'unknown'}`}`);
+                }
+                // Check for end of stream (both null and undefined indicate end)
+                if (data == null) {
+                    // End of stream - both null and undefined are valid end signals
+                    if (verbose) {
+                        logger.info(`[html-worker] End of RSC stream for route: ${id}`);
+                    }
+                    rscStream.end();
+                    return;
+                }
+                // RSC chunk data - ensure it's a valid chunk
+                if (!streamStarted) {
+                    streamStarted = true;
+                    if (verbose) {
+                        logger.info(`[html-worker] Starting HTML render process for route: ${id} after receiving first chunk`);
+                    }
+                    // Start the HTML render process when we receive the first chunk
+                    startHtmlRender();
+                }
+                // Write RSC chunk to the stream
+                rscStream.write(data);
+                if (verbose) {
+                    logger.info(`[html-worker] Wrote RSC chunk to stream for route: ${id}`);
+                }
+                // Send READY message to indicate we're ready for more data
+                // This implements flow control to prevent backpressure
+                if (verbose) {
+                    logger.info(`[html-worker] Sending READY signal for route: ${id}`);
+                }
+                controlPort.postMessage({ type: "READY", id: id });
+            };
         }
-        break;
-      }
-      case "RSC_END": {
-        const renderState = activeRenders.get(id);
-        if (!renderState) {
-          sendMessage({
-            type: "ERROR",
-            id,
-            error: new Error("No render state found")
-          });
-          return;
+        catch (error) {
+            controlPort.postMessage({
+                type: "ERROR",
+                id,
+                error: {
+                    name: error instanceof Error ? error.name : "UnknownError",
+                    message: error instanceof Error ? error.message : String(error),
+                    stack: error instanceof Error ? error.stack : undefined,
+                },
+            });
         }
-        break;
-      }
-      case "CLEANUP": {
-        cleanup(id);
-        break;
-      }
-      case "SHUTDOWN": {
-        if (id === "*") {
-          for (const [renderId] of activeRenders) {
-            cleanup(renderId);
-          }
-        } else {
-          cleanup(id);
+    }
+    else if (msg && msg.type === "CLEANUP") {
+        // Handle cleanup message to reset worker state between page renders
+        const { id } = msg;
+        if (verbose) {
+            logger.info(`[html-worker] Cleaning up worker state for route: ${id}`);
+        }
+        // Reset any internal state that might persist between renders
+        // This prevents race conditions where stale state affects subsequent renders
+        // Send cleanup complete message via parentPort
+        if (typeof parentPort !== "undefined" && parentPort) {
+            parentPort.postMessage({
+                type: "CLEANUP_COMPLETE",
+                id: id,
+            });
+        }
+    }
+    else if (msg && msg.type === "SHUTDOWN") {
+        // Handle shutdown message
+        const { id } = msg;
+        // Send shutdown complete message via parentPort
+        if (typeof parentPort !== "undefined" && parentPort) {
+            parentPort.postMessage({
+                type: "SHUTDOWN_COMPLETE",
+                id: id,
+            });
         }
-        sendMessage({
-          type: "SHUTDOWN_COMPLETE",
-          id
-        });
-        break;
-      }
+        // Exit the worker
+        process.exit(0);
     }
-  } catch (error) {
-    sendMessage({
-      type: "ERROR",
-      id,
-      error: toError(error)
-    });
-  }
 }
-
-export { messageHandler };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/plugin/worker/html/state.d.ts

@@ -0,0 +1,10 @@
+import type { PassThrough } from "node:stream";
+export declare const activeStreams: Map<string, PassThrough>;
+export declare const moduleIds: Map<string, string>;
+export declare const temporaryReferences: WeakMap<any, any>;
+export declare function addModuleId(id: string, url: string): void;
+export declare function cacheComponent(id: string, component: any): void;
+export declare function getCachedComponent(id: string): any;
+export declare function hasCachedComponent(id: string): boolean;
+export declare function getModuleId(id: string): string | undefined;
+//# sourceMappingURL=state.d.ts.map

package/dist/plugin/worker/html/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../plugin/worker/html/state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAI/C,eAAO,MAAM,aAAa,0BAAiC,CAAC;AAG5D,eAAO,MAAM,SAAS,qBAA4B,CAAC;AAGnD,eAAO,MAAM,mBAAmB,mBAA0B,CAAC;AAG3D,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,QAElD;AAGD,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,QAGxD;AAGD,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,GAAG,GAAG,CAGlD;AAGD,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAGtD;AAED,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE1D"}

package/dist/plugin/worker/html/state.js

@@ -0,0 +1,28 @@
+import { getModuleRef } from "../../helpers/moduleRefs.js";
+// Track active RSC streams
+export const activeStreams = new Map();
+// Track module IDs
+export const moduleIds = new Map();
+// Track resolved components cache using Map for better memory management
+export const temporaryReferences = new WeakMap();
+export function addModuleId(id, url) {
+    moduleIds.set(id, url);
+}
+// Helper to cache a resolved component
+export function cacheComponent(id, component) {
+    const moduleRef = getModuleRef(id);
+    temporaryReferences.set(moduleRef, component);
+}
+// Helper to get a cached component
+export function getCachedComponent(id) {
+    const moduleRef = getModuleRef(id);
+    return temporaryReferences.get(moduleRef);
+}
+// Helper to check if a component is cached
+export function hasCachedComponent(id) {
+    const moduleRef = getModuleRef(id);
+    return temporaryReferences.has(moduleRef);
+}
+export function getModuleId(id) {
+    return moduleIds.get(id);
+}