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

package/dist/plugin/dev-server/configureRequestHandler.client.js

@@ -0,0 +1,307 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import 'node:worker_threads';
+import { serializedOptions } from '../helpers/serializeUserOptions.js';
+import { requestInfo } from '../helpers/requestInfo.js';
+import { restartWorker } from './restartWorker.client.js';
+import { handleRscStream } from '../stream/handleRscStream.client.js';
+import { getRouteFiles } from '../helpers/getRouteFiles.js';
+import { handleServerAction } from './handleServerAction.client.js';
+import { handleError } from '../error/handleError.js';
+import { getNodeEnv } from '../config/getNodeEnv.js';
+import { setupGlobalErrorHandler, cleanupGlobalErrorHandler } from '../error/setupGlobalErrorHandler.js';
+import { pipeToResponse } from '../helpers/pipeToResponse.js';
+
+let hasInvalidatedModules = false;
+function markModulesInvalidated() {
+  hasInvalidatedModules = true;
+}
+const configureRequestHandler = async function _configureWorkerRequestHandler({
+  server,
+  autoDiscoveredFiles,
+  userOptions: _userOptions,
+  configEnv,
+  hmrChannel,
+  onWorkerCreated
+}) {
+  const logger = server.config.customLogger || server.config.logger;
+  const {
+    // remove these
+    moduleBaseURL: _moduleBaseURL,
+    ...handlerUserOptions
+  } = _userOptions;
+  const handlerOptions = Object.assign({}, handlerUserOptions, {
+    moduleBaseURL: server.config.base,
+    projectRoot: _userOptions.projectRoot || server.config.root,
+    logger
+  });
+  setupGlobalErrorHandler({
+    panicThreshold: handlerOptions.panicThreshold,
+    logger,
+    verbose: handlerOptions.verbose
+  });
+  let currentWorker = null;
+  let restartWorkerForHMR = null;
+  server.ws.on("restart", async () => {
+    logger.info("[react-client] Server restarting, shutting down worker...");
+    if (currentWorker) {
+      currentWorker.postMessage({
+        type: "SHUTDOWN",
+        id: "*"
+      });
+      await new Promise((resolve, reject) => {
+        currentWorker?.on("message", (message) => {
+          if (message.type === "SHUTDOWN_COMPLETE") {
+            resolve(true);
+          } else {
+            reject("Did not receive SHUTDOWN_COMPLETE");
+          }
+        });
+      });
+      currentWorker.removeAllListeners();
+      currentWorker = null;
+    }
+    cleanupGlobalErrorHandler();
+  });
+  const handler = async (req, res, next) => {
+    if (!req.url) return next();
+    const info = requestInfo(req, handlerOptions, "");
+    const handlerOptionsWithUrl = {
+      ...handlerOptions,
+      url: info.url
+    };
+    if (handlerOptions.verbose) {
+      server.config.logger.info(`[configureRequestHandler] handlerOptionsWithUrl.projectRoot: ${handlerOptionsWithUrl.projectRoot}`);
+      server.config.logger.info(`[configureRequestHandler] handlerOptions.projectRoot: ${handlerOptions.projectRoot}`);
+    }
+    const serializedUserOptions = serializedOptions(
+      handlerOptionsWithUrl,
+      autoDiscoveredFiles
+    );
+    if (!restartWorkerForHMR) {
+      restartWorkerForHMR = async () => {
+        if (currentWorker) {
+          currentWorker = await restartWorker({
+            server,
+            autoDiscoveredFiles,
+            userOptions: serializedUserOptions,
+            configEnv,
+            hmrChannel
+          });
+          if (currentWorker && restartWorkerForHMR) {
+            onWorkerCreated?.(currentWorker, restartWorkerForHMR);
+          }
+        } else {
+          currentWorker = await restartWorker({
+            server,
+            autoDiscoveredFiles,
+            userOptions: serializedUserOptions,
+            configEnv,
+            hmrChannel
+          });
+          if (currentWorker && restartWorkerForHMR) {
+            onWorkerCreated?.(currentWorker, restartWorkerForHMR);
+          }
+        }
+      };
+    }
+    if (handlerOptions.verbose) {
+      server.config.logger.info(`[configureRequestHandler] serializedUserOptions.projectRoot: ${serializedUserOptions.projectRoot}`);
+    }
+    if (info.isServerActionRequest) {
+      if (!currentWorker) {
+        currentWorker = await restartWorker({
+          server,
+          autoDiscoveredFiles,
+          userOptions: serializedUserOptions,
+          configEnv,
+          hmrChannel
+        });
+      }
+      if (!currentWorker) {
+        throw new Error("Failed to start worker");
+      }
+      return handleServerAction(req, res, currentWorker, logger);
+    }
+    if (!info.isRscRequest) {
+      return next();
+    }
+    const routeFiles = await getRouteFiles(
+      info.route,
+      autoDiscoveredFiles,
+      handlerOptions,
+      logger
+    );
+    if (routeFiles.type === "error") {
+      const panicError = handleError({
+        error: routeFiles.error,
+        logger,
+        mode: getNodeEnv(server.config.mode),
+        panicThreshold: handlerOptions.panicThreshold,
+        critical: false});
+      if (panicError != null) {
+        throw panicError;
+      }
+      return next(routeFiles.error);
+    }
+    const pagePath = routeFiles.page;
+    const propsPath = routeFiles.props;
+    const rootPath = routeFiles.root;
+    let resolvedPageProps;
+    if (propsPath) {
+      try {
+        const fullPropsPath = `${handlerOptions.projectRoot}/${propsPath}`;
+        const serverEnv = server.environments?.["server"];
+        let propsModule;
+        if (handlerOptions.verbose) {
+          logger.info(`[configureRequestHandler] Pre-loading props from: ${fullPropsPath}`);
+        }
+        if (serverEnv && "runner" in serverEnv && serverEnv.runner) {
+          try {
+            propsModule = await serverEnv.runner.import(fullPropsPath);
+          } catch (runnerError) {
+            if (handlerOptions.verbose) {
+              logger.info(`[configureRequestHandler] Props will be loaded by worker (expected in dev:ssr mode)`);
+            }
+            propsModule = null;
+          }
+        } else {
+          propsModule = null;
+        }
+        const propsExportName = handlerOptions.propsExportName || "props";
+        if (propsModule) {
+          const propsExport = propsModule[propsExportName];
+          if (typeof propsExport === "function") {
+            let result = propsExport(info.url);
+            if (result instanceof Promise) {
+              result = await result;
+            }
+            resolvedPageProps = result;
+            if (handlerOptions.verbose) {
+              logger.info(`[configureRequestHandler] Pre-loaded props for ${info.route}: ${Object.keys(resolvedPageProps || {}).length} keys`);
+            }
+          } else if (propsExport && typeof propsExport === "object") {
+            resolvedPageProps = propsExport;
+          }
+        }
+      } catch (error) {
+        if (handlerOptions.verbose) {
+          logger.warn(`[configureRequestHandler] Failed to pre-load props: ${error}`);
+        }
+      }
+    }
+    try {
+      res.setHeader("Content-Type", info.contentType);
+      res.setHeader("Transfer-Encoding", "chunked");
+      res.setHeader("Connection", "keep-alive");
+      res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
+      res.setHeader("Pragma", "no-cache");
+      res.setHeader("Expires", "0");
+      const userOnMetrics = handlerOptions.onMetrics;
+      if (!currentWorker) {
+        currentWorker = await restartWorker({
+          server,
+          autoDiscoveredFiles,
+          userOptions: serializedUserOptions,
+          configEnv,
+          hmrChannel
+        });
+        hasInvalidatedModules = false;
+      } else if (hasInvalidatedModules) {
+        logger.info(`[configureRequestHandler] Modules invalidated, restarting worker to clear Node.js module cache...`);
+        currentWorker = await restartWorker({
+          server,
+          autoDiscoveredFiles,
+          userOptions: serializedUserOptions,
+          configEnv,
+          hmrChannel
+        });
+        hasInvalidatedModules = false;
+      } else {
+      }
+      if (!currentWorker) {
+        throw new Error("Failed to start worker");
+      }
+      onWorkerCreated?.(currentWorker, restartWorkerForHMR);
+      const stream = handleRscStream({
+        options: {
+          ...serializedUserOptions,
+          worker: currentWorker,
+          id: info.route,
+          type: "INIT",
+          logger,
+          // we make the worker stream aware of the route, pagePath, propsPath, rootPath, htmlPath
+          route: info.route,
+          url: info.url,
+          pagePath,
+          propsPath,
+          // Pass pre-resolved props (loaded via Vite's ssrLoadModule for proper transforms)
+          resolvedPageProps,
+          rootPath,
+          // CRITICAL: For RSC requests, use htmlPath: "" for headless mode (no Html wrapper)
+          // This prevents hydration errors where <html> would be rendered inside #root div
+          htmlPath: "",
+          // Empty string = headless RSC (no Html wrapper)
+          // Component overrides (undefined for file-based components in client dev)
+          HtmlComponent: void 0,
+          RootComponent: void 0,
+          // Use userOptions.projectRoot if available, otherwise fall back to server.config.root
+          projectRoot: serializedUserOptions.projectRoot || server.config.root,
+          build: {
+            ...serializedUserOptions.build || {},
+            pages: Array.isArray(serializedUserOptions.build?.pages) ? serializedUserOptions.build.pages : []
+          },
+          manifest: {},
+          cssFiles: /* @__PURE__ */ new Map(),
+          globalCss: /* @__PURE__ */ new Map(),
+          serverPipeableStreamOptions: serializedUserOptions.serverPipeableStreamOptions,
+          clientPipeableStreamOptions: serializedUserOptions.clientPipeableStreamOptions
+        },
+        handlers: {
+          onMetrics: (id, metrics) => {
+            metrics.route = id;
+            userOnMetrics?.(metrics);
+          },
+          onHmrAccept: () => {
+          },
+          onHmrUpdate: () => {
+          },
+          onShellError: (_id, _error) => {
+          }
+        },
+        ...handlerOptions
+      });
+      pipeToResponse({
+        stream,
+        response: res,
+        contentType: info.contentType,
+        logger,
+        verbose: handlerOptions.verbose,
+        panicThreshold: handlerOptions.panicThreshold,
+        context: "configureWorkerRequestHandler"
+      });
+    } catch (error) {
+      const panicError = handleError({
+        error,
+        logger,
+        mode: getNodeEnv(server.config.mode),
+        panicThreshold: handlerOptions.panicThreshold,
+        critical: false});
+      if (panicError != null) {
+        throw panicError;
+      }
+      if (!res.headersSent) {
+        res.statusCode = 500;
+        res.setHeader("Content-Type", "text/x-component; charset=utf-8");
+      }
+      res.end();
+    }
+  };
+  server.middlewares.use(handler);
+};
+
+export { configureRequestHandler, markModulesInvalidated };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"configureRequestHandler.client.js","sources":["../../../plugin/dev-server/configureRequestHandler.client.ts"],"sourcesContent":["import type { RequestHandler } from \"../types.js\";\nimport { type Worker } from \"node:worker_threads\";\nimport { serializedOptions } from \"../helpers/serializeUserOptions.js\";\nimport { requestInfo } from \"../helpers/requestInfo.js\";\nimport { restartWorker } from \"./restartWorker.client.js\";\nimport { handleRscStream } from \"../stream/handleRscStream.client.js\";\nimport { getRouteFiles } from \"../helpers/getRouteFiles.js\";\nimport type { RscWorkerInputMessage } from \"../worker/rsc/types.js\";\n\nimport { handleServerAction } from \"./handleServerAction.client.js\";\nimport type { ConfigureWorkerRequestHandlerFn } from \"../react-client/types.js\";\nimport { handleError } from \"../error/handleError.js\";\nimport { getNodeEnv } from \"../config/getNodeEnv.js\";\nimport { setupGlobalErrorHandler, cleanupGlobalErrorHandler } from \"../error/setupGlobalErrorHandler.js\";\nimport { pipeToResponse } from \"../helpers/pipeToResponse.js\";\n\n// Shared state to track if modules have been invalidated\n// This allows us to restart the worker on the next request to clear Node.js module cache\nlet hasInvalidatedModules = false;\n\n/**\n * Mark that modules have been invalidated - worker will be restarted on next request\n */\nexport function markModulesInvalidated(): void {\n  hasInvalidatedModules = true;\n}\n\n/**\n * Configures the worker request handler.\n * @param server - The Vite dev server\n * @param autoDiscoveredFiles - The auto discovered files\n * @param userOptions - The user options\n */\nexport const configureRequestHandler: ConfigureWorkerRequestHandlerFn =\n  async function _configureWorkerRequestHandler({\n    server,\n    autoDiscoveredFiles,\n    userOptions: _userOptions,\n    configEnv,\n    hmrChannel,\n    onWorkerCreated,\n  }) {\n    const logger = server.config.customLogger || server.config.logger;\n    const {\n      // remove these\n      moduleBaseURL: _moduleBaseURL,\n      ...handlerUserOptions\n    } = _userOptions;\n    const handlerOptions = Object.assign({}, handlerUserOptions, {\n      moduleBaseURL: server.config.base,\n      projectRoot: _userOptions.projectRoot || server.config.root,\n      logger: logger,\n    });\n\n    // Set up global error handler for all_errors panic threshold\n    setupGlobalErrorHandler({\n      panicThreshold: handlerOptions.panicThreshold,\n      logger: logger,\n      verbose: handlerOptions.verbose,\n    });\n\n    // Start the worker\n    let currentWorker: Worker | null = null;\n    let restartWorkerForHMR: (() => Promise<void>) | null = null;\n\n    // Handle server restarts\n    server.ws.on(\"restart\", async () => {\n      logger.info(\"[react-client] Server restarting, shutting down worker...\");\n      if (currentWorker) {\n        currentWorker.postMessage({\n          type: \"SHUTDOWN\",\n          id: \"*\",\n        } satisfies RscWorkerInputMessage);\n        await new Promise((resolve, reject) => {\n          currentWorker?.on(\"message\", (message) => {\n            if (message.type === \"SHUTDOWN_COMPLETE\") {\n              resolve(true);\n            } else {\n              reject(\"Did not receive SHUTDOWN_COMPLETE\");\n            }\n          });\n        });\n        currentWorker.removeAllListeners();\n        currentWorker = null;\n      }\n      \n      // Clean up global error handler\n      cleanupGlobalErrorHandler();\n    });\n\n    // Create the request handler\n    const handler: RequestHandler = async (req, res, next) => {\n      if (!req.url) return next();\n\n      const info = requestInfo(req, handlerOptions, \"\");\n      const handlerOptionsWithUrl = {\n        ...handlerOptions,\n        url: info.url,\n      };\n      \n      if (handlerOptions.verbose) {\n        server.config.logger.info(`[configureRequestHandler] handlerOptionsWithUrl.projectRoot: ${handlerOptionsWithUrl.projectRoot}`);\n        server.config.logger.info(`[configureRequestHandler] handlerOptions.projectRoot: ${handlerOptions.projectRoot}`);\n      }\n      \n      // Serialize user options for worker\n      const serializedUserOptions = serializedOptions(\n        handlerOptionsWithUrl,\n        autoDiscoveredFiles\n      );\n      \n      // Define restart function for HMR (needs serializedUserOptions)\n      if (!restartWorkerForHMR) {\n        restartWorkerForHMR = async () => {\n          if (currentWorker) {\n            currentWorker = await restartWorker({\n              server,\n              autoDiscoveredFiles,\n              userOptions: serializedUserOptions,\n              configEnv: configEnv,\n              hmrChannel,\n            });\n            if (currentWorker && restartWorkerForHMR) {\n              onWorkerCreated?.(currentWorker, restartWorkerForHMR);\n            }\n          } else {\n            // Worker doesn't exist yet, create it\n            currentWorker = await restartWorker({\n              server,\n              autoDiscoveredFiles,\n              userOptions: serializedUserOptions,\n              configEnv: configEnv,\n              hmrChannel,\n            });\n            if (currentWorker && restartWorkerForHMR) {\n              onWorkerCreated?.(currentWorker, restartWorkerForHMR);\n            }\n          }\n        };\n      }\n      \n      if (handlerOptions.verbose) {\n        server.config.logger.info(`[configureRequestHandler] serializedUserOptions.projectRoot: ${serializedUserOptions.projectRoot}`);\n      }\n\n      // Handle server action requests\n      if (info.isServerActionRequest) {\n        if (!currentWorker) {\n          currentWorker = await restartWorker({\n            server,\n            autoDiscoveredFiles,\n            userOptions: serializedUserOptions,\n            configEnv: configEnv,\n            hmrChannel,\n          });\n        }\n        if (!currentWorker) {\n          throw new Error(\"Failed to start worker\");\n        }\n        return handleServerAction(req, res, currentWorker, logger);\n      }\n\n      // Handle RSC requests\n      if (!info.isRscRequest) {\n        return next();\n      }\n\n      const routeFiles = await getRouteFiles(\n        info.route,\n        autoDiscoveredFiles,\n        handlerOptions,\n        logger\n      );\n      if (routeFiles.type === \"error\") {\n        const   panicError = handleError({\n          error: routeFiles.error,\n          logger,\n          mode: getNodeEnv(server.config.mode),\n          panicThreshold: handlerOptions.panicThreshold,\n          critical: false,\n          context: \"configureWorkerRequestHandler\",\n        });\n        if (panicError != null) {\n          throw panicError;\n        }\n        return next(routeFiles.error);\n      }\n      const pagePath = routeFiles.page;\n      const propsPath = routeFiles.props;\n      const rootPath = routeFiles.root;\n      // Note: htmlPath not used for RSC requests (always \"\" for headless mode)\n      \n      // Pre-load props on main thread to apply Vite transforms (server actions need this)\n      // Use the server environment runner if available (Vite 6+), otherwise fall back to ssrLoadModule\n      // NOTE: In dev:ssr mode, this will fail because main thread lacks react-server condition.\n      // That's expected - the worker will load props instead.\n      let resolvedPageProps: Record<string, unknown> | undefined;\n      if (propsPath) {\n        try {\n          const fullPropsPath = `${handlerOptions.projectRoot}/${propsPath}`;\n          const serverEnv = server.environments?.['server'];\n          let propsModule: any;\n          \n          if (handlerOptions.verbose) {\n            logger.info(`[configureRequestHandler] Pre-loading props from: ${fullPropsPath}`);\n          }\n          \n          if (serverEnv && 'runner' in serverEnv && serverEnv.runner) {\n            // Vite 6+ server environment with react-server conditions\n            try {\n              propsModule = await (serverEnv.runner as any).import(fullPropsPath);\n            } catch (runnerError: any) {\n              // Expected in dev:ssr mode - main thread lacks react-server condition\n              // Worker will load props instead (this is the normal path for dev:ssr)\n              if (handlerOptions.verbose) {\n                logger.info(`[configureRequestHandler] Props will be loaded by worker (expected in dev:ssr mode)`);\n              }\n              propsModule = null;\n            }\n          } else {\n            // No server environment - let the worker handle it\n            propsModule = null;\n          }\n          const propsExportName = handlerOptions.propsExportName || \"props\";\n          \n          // Only process if we got a module (server runner succeeded)\n          if (propsModule) {\n            const propsExport = propsModule[propsExportName];\n          \n            if (typeof propsExport === \"function\") {\n            // Call the props function with the URL\n            let result = propsExport(info.url);\n            if (result instanceof Promise) {\n              result = await result;\n            }\n            resolvedPageProps = result;\n            if (handlerOptions.verbose) {\n              logger.info(`[configureRequestHandler] Pre-loaded props for ${info.route}: ${Object.keys(resolvedPageProps || {}).length} keys`);\n            }\n          } else if (propsExport && typeof propsExport === \"object\") {\n            resolvedPageProps = propsExport;\n          }\n          }  // end if (propsModule)\n        } catch (error) {\n          if (handlerOptions.verbose) {\n            logger.warn(`[configureRequestHandler] Failed to pre-load props: ${error}`);\n          }\n          // Continue without pre-loaded props, worker will try to load them\n        }\n      }\n      \n      try {\n        // Set up response headers for streaming\n        res.setHeader(\"Content-Type\", info.contentType);\n        res.setHeader(\"Transfer-Encoding\", \"chunked\");\n        res.setHeader(\"Connection\", \"keep-alive\");\n        \n        // CRITICAL: Disable caching in development mode\n        // Without this, browsers cache RSC streams and don't show updates\n        res.setHeader(\"Cache-Control\", \"no-cache, no-store, must-revalidate\");\n        res.setHeader(\"Pragma\", \"no-cache\");\n        res.setHeader(\"Expires\", \"0\");\n\n        const userOnMetrics = handlerOptions.onMetrics;\n        \n        // CRITICAL: If modules have been invalidated, restart the worker to clear Node.js's ES module cache\n        // This ensures file changes are picked up even on refresh\n        // Node.js caches ES modules, and the only way to clear that cache is to restart the worker\n        if (!currentWorker) {\n          currentWorker = await restartWorker({\n            server,\n            autoDiscoveredFiles,\n            userOptions: serializedUserOptions,\n            configEnv: configEnv,\n            hmrChannel,\n          });\n          hasInvalidatedModules = false; // Reset flag after creating worker\n        } else if (hasInvalidatedModules) {\n          // Worker exists but modules are invalidated - restart to clear Node.js cache\n          logger.info(`[configureRequestHandler] Modules invalidated, restarting worker to clear Node.js module cache...`);\n          currentWorker = await restartWorker({\n            server,\n            autoDiscoveredFiles,\n            userOptions: serializedUserOptions,\n            configEnv: configEnv,\n            hmrChannel,\n          });\n          hasInvalidatedModules = false; // Reset flag after restarting\n        } else {\n          // Worker already exists and no invalidations - reuse it\n          // Note: unified worker streams handle their own listeners\n        }\n        if (!currentWorker) {\n          throw new Error(\"Failed to start worker\");\n        }\n        // Notify about worker creation\n        onWorkerCreated?.(currentWorker, restartWorkerForHMR);\n\n        const stream = handleRscStream({\n          options: {\n            ...serializedUserOptions,\n            worker: currentWorker,\n            id: info.route,\n            type: \"INIT\",\n            logger,\n            // we make the worker stream aware of the route, pagePath, propsPath, rootPath, htmlPath\n            route: info.route,\n            url: info.url,\n            pagePath: pagePath,\n            propsPath: propsPath,\n            // Pass pre-resolved props (loaded via Vite's ssrLoadModule for proper transforms)\n            resolvedPageProps: resolvedPageProps,\n            rootPath: rootPath,\n            // CRITICAL: For RSC requests, use htmlPath: \"\" for headless mode (no Html wrapper)\n            // This prevents hydration errors where <html> would be rendered inside #root div\n            htmlPath: \"\",  // Empty string = headless RSC (no Html wrapper)\n            // Component overrides (undefined for file-based components in client dev)\n            HtmlComponent: undefined,\n            RootComponent: undefined,\n            // Use userOptions.projectRoot if available, otherwise fall back to server.config.root\n            projectRoot: serializedUserOptions.projectRoot || server.config.root,\n            build: {\n              ...(serializedUserOptions.build || {}),\n              pages: Array.isArray(serializedUserOptions.build?.pages)\n                ? serializedUserOptions.build.pages\n                : [],\n            },\n            manifest: {},\n            cssFiles: new Map(),\n            globalCss: new Map(),\n            serverPipeableStreamOptions: serializedUserOptions.serverPipeableStreamOptions,\n            clientPipeableStreamOptions: serializedUserOptions.clientPipeableStreamOptions,\n          } as any,\n          handlers: {\n            onMetrics: (id, metrics) => {\n              metrics.route = id;\n              userOnMetrics?.(metrics);\n            },\n            onHmrAccept: () => {\n            },\n            onHmrUpdate: () => {\n            },\n            onShellError: (_id, _error) => {\n            },\n          },\n          ...handlerOptions,\n        });\n\n        // Pipe the stream to the response using the helper\n        pipeToResponse({\n          stream,\n          response: res,\n          contentType: info.contentType,\n          logger,\n          verbose: handlerOptions.verbose,\n          panicThreshold: handlerOptions.panicThreshold,\n          context: \"configureWorkerRequestHandler\",\n        });\n        // Response is now being streamed - no need to wait for timeout\n      } catch (error) {\n        const panicError = handleError({\n          error,\n          logger,\n          mode: getNodeEnv(server.config.mode),\n          panicThreshold: handlerOptions.panicThreshold,\n          critical: false,\n          context: \"configureWorkerRequestHandler\",\n        });\n        if (panicError != null) {\n          throw panicError;\n        }\n        if (!res.headersSent) {\n          res.statusCode = 500;\n          res.setHeader(\"Content-Type\", \"text/x-component; charset=utf-8\");\n        }\n        res.end();\n      }\n    };\n    // attach handler to the server\n    server.middlewares.use(handler);\n    // port check, should be handled by strictPort\n  };\n"],"names":[],"mappings":"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"}

package/dist/plugin/dev-server/configureRequestHandler.d.ts

@@ -0,0 +1,2 @@
+export declare const configureRequestHandler: any;
+//# sourceMappingURL=configureRequestHandler.d.ts.map

package/dist/plugin/dev-server/configureRequestHandler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configureRequestHandler.d.ts","sourceRoot":"","sources":["../../../plugin/dev-server/configureRequestHandler.ts"],"names":[],"mappings":"AAKA,eAAO,MAAQ,uBAAuB,KAErC,CAAC"}

package/dist/plugin/dev-server/configureRequestHandler.js

@@ -0,0 +1,4 @@
+import { getCondition } from "../config/getCondition.js";
+const dir = new URL("./", import.meta.url).pathname.replace(/\/$/, "");
+const condition = getCondition("");
+export const { configureRequestHandler } = (await import(`${dir}/configureRequestHandler.${condition}.js`));

package/dist/plugin/dev-server/configureRequestHandler.server.d.ts

@@ -0,0 +1,6 @@
+import type { ConfigureWorkerRequestHandlerFn } from "../react-client/types.js";
+/**
+ * Server version of configureRequestHandler - delegates to react-server's configureReactServer
+ */
+export declare const configureRequestHandler: ConfigureWorkerRequestHandlerFn;
+//# sourceMappingURL=configureRequestHandler.server.d.ts.map

package/dist/plugin/dev-server/configureRequestHandler.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"configureRequestHandler.server.d.ts","sourceRoot":"","sources":["../../../plugin/dev-server/configureRequestHandler.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,+BAA+B,EAAE,MAAM,0BAA0B,CAAC;AAIhF;;GAEG;AACH,eAAO,MAAM,uBAAuB,EAAE,+BAsCrC,CAAC"}

package/dist/plugin/dev-server/configureRequestHandler.server.js

@@ -0,0 +1,44 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { handleError } from '../error/handleError.js';
+import { configureReactServer } from './configureReactServer.server.js';
+
+const configureRequestHandler = async function _configureRequestHandler({
+  server,
+  autoDiscoveredFiles,
+  userOptions,
+  serverManifest,
+  resolvedConfig,
+  hmrChannel,
+  onWorkerCreated
+}) {
+  try {
+    if (server.config.logger) {
+      server.config.logger.info("[configureRequestHandler:server] Delegating to react-server configureReactServer");
+    }
+    configureReactServer({
+      server,
+      autoDiscoveredFiles,
+      userOptions,
+      serverManifest,
+      resolvedConfig,
+      hmrChannel,
+      onWorkerCreated
+    });
+  } catch (error) {
+    const panicError = handleError({
+      error,
+      logger: server.config.logger,
+      panicThreshold: "none"});
+    if (panicError) {
+      throw panicError;
+    }
+    throw new Error("Failed to configure request handler");
+  }
+};
+
+export { configureRequestHandler };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlndXJlUmVxdWVzdEhhbmRsZXIuc2VydmVyLmpzIiwic291cmNlcyI6WyIuLi8uLi8uLi9wbHVnaW4vZGV2LXNlcnZlci9jb25maWd1cmVSZXF1ZXN0SGFuZGxlci5zZXJ2ZXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBDb25maWd1cmVXb3JrZXJSZXF1ZXN0SGFuZGxlckZuIH0gZnJvbSBcIi4uL3JlYWN0LWNsaWVudC90eXBlcy5qc1wiO1xuaW1wb3J0IHsgaGFuZGxlRXJyb3IgfSBmcm9tIFwiLi4vZXJyb3IvaGFuZGxlRXJyb3IuanNcIjtcbmltcG9ydCB7IGNvbmZpZ3VyZVJlYWN0U2VydmVyIH0gZnJvbSBcIi4vY29uZmlndXJlUmVhY3RTZXJ2ZXIuc2VydmVyLmpzXCI7XG5cbi8qKlxuICogU2VydmVyIHZlcnNpb24gb2YgY29uZmlndXJlUmVxdWVzdEhhbmRsZXIgLSBkZWxlZ2F0ZXMgdG8gcmVhY3Qtc2VydmVyJ3MgY29uZmlndXJlUmVhY3RTZXJ2ZXJcbiAqL1xuZXhwb3J0IGNvbnN0IGNvbmZpZ3VyZVJlcXVlc3RIYW5kbGVyOiBDb25maWd1cmVXb3JrZXJSZXF1ZXN0SGFuZGxlckZuID0gYXN5bmMgZnVuY3Rpb24gX2NvbmZpZ3VyZVJlcXVlc3RIYW5kbGVyKHtcbiAgc2VydmVyLFxuICBhdXRvRGlzY292ZXJlZEZpbGVzLFxuICB1c2VyT3B0aW9ucyxcbiAgc2VydmVyTWFuaWZlc3QsXG4gIHJlc29sdmVkQ29uZmlnLFxuICBobXJDaGFubmVsLFxuICBvbldvcmtlckNyZWF0ZWQsXG59KSB7XG4gIHRyeSB7XG4gICAgaWYgKHNlcnZlci5jb25maWcubG9nZ2VyKSB7XG4gICAgICBzZXJ2ZXIuY29uZmlnLmxvZ2dlci5pbmZvKFwiW2NvbmZpZ3VyZVJlcXVlc3RIYW5kbGVyOnNlcnZlcl0gRGVsZWdhdGluZyB0byByZWFjdC1zZXJ2ZXIgY29uZmlndXJlUmVhY3RTZXJ2ZXJcIik7XG4gICAgfVxuXG4gICAgLy8gSW4gc2VydmVyIG1vZGUsIGRlbGVnYXRlIHRvIHJlYWN0LXNlcnZlcidzIGNvbmZpZ3VyZVJlYWN0U2VydmVyXG4gICAgLy8gVGhpcyBoYW5kbGVzIHJlcXVlc3RzIGRpcmVjdGx5IHdpdGhvdXQgd29ya2Vyc1xuICAgIGNvbmZpZ3VyZVJlYWN0U2VydmVyKHtcbiAgICAgIHNlcnZlcixcbiAgICAgIGF1dG9EaXNjb3ZlcmVkRmlsZXMsXG4gICAgICB1c2VyT3B0aW9ucyxcbiAgICAgIHNlcnZlck1hbmlmZXN0LFxuICAgICAgcmVzb2x2ZWRDb25maWcsXG4gICAgICBobXJDaGFubmVsLFxuICAgICAgb25Xb3JrZXJDcmVhdGVkLFxuICAgIH0pO1xuICB9IGNhdGNoIChlcnJvcikge1xuICAgIGNvbnN0IHBhbmljRXJyb3IgPSBoYW5kbGVFcnJvcih7XG4gICAgICBlcnJvcixcbiAgICAgIGxvZ2dlcjogc2VydmVyLmNvbmZpZy5sb2dnZXIsXG4gICAgICBwYW5pY1RocmVzaG9sZDogXCJub25lXCIsXG4gICAgICBjb250ZXh0OiBcImNvbmZpZ3VyZVJlcXVlc3RIYW5kbGVyLnNlcnZlclwiLFxuICAgIH0pO1xuICAgIFxuICAgIGlmIChwYW5pY0Vycm9yKSB7XG4gICAgICB0aHJvdyBwYW5pY0Vycm9yO1xuICAgIH1cbiAgICB0aHJvdyBuZXcgRXJyb3IoXCJGYWlsZWQgdG8gY29uZmlndXJlIHJlcXVlc3QgaGFuZGxlclwiKTtcbiAgfVxufTsgIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7O0FBT2EsTUFBQSx1QkFBQSxHQUEyRCxlQUFlLHdCQUF5QixDQUFBO0FBQUEsRUFDOUcsTUFBQTtBQUFBLEVBQ0EsbUJBQUE7QUFBQSxFQUNBLFdBQUE7QUFBQSxFQUNBLGNBQUE7QUFBQSxFQUNBLGNBQUE7QUFBQSxFQUNBLFVBQUE7QUFBQSxFQUNBO0FBQ0YsQ0FBRyxFQUFBO0FBQ0QsRUFBSSxJQUFBO0FBQ0YsSUFBSSxJQUFBLE1BQUEsQ0FBTyxPQUFPLE1BQVEsRUFBQTtBQUN4QixNQUFPLE1BQUEsQ0FBQSxNQUFBLENBQU8sTUFBTyxDQUFBLElBQUEsQ0FBSyxrRkFBa0YsQ0FBQTtBQUFBO0FBSzlHLElBQXFCLG9CQUFBLENBQUE7QUFBQSxNQUNuQixNQUFBO0FBQUEsTUFDQSxtQkFBQTtBQUFBLE1BQ0EsV0FBQTtBQUFBLE1BQ0EsY0FBQTtBQUFBLE1BQ0EsY0FBQTtBQUFBLE1BQ0EsVUFBQTtBQUFBLE1BQ0E7QUFBQSxLQUNELENBQUE7QUFBQSxXQUNNLEtBQU8sRUFBQTtBQUNkLElBQUEsTUFBTSxhQUFhLFdBQVksQ0FBQTtBQUFBLE1BQzdCLEtBQUE7QUFBQSxNQUNBLE1BQUEsRUFBUSxPQUFPLE1BQU8sQ0FBQSxNQUFBO0FBQUEsTUFDdEIsY0FBZ0IsRUFBQSxNQUVsQixDQUFDLENBQUE7QUFFRCxJQUFBLElBQUksVUFBWSxFQUFBO0FBQ2QsTUFBTSxNQUFBLFVBQUE7QUFBQTtBQUVSLElBQU0sTUFBQSxJQUFJLE1BQU0scUNBQXFDLENBQUE7QUFBQTtBQUV6RDs7OzsifQ==

package/dist/plugin/dev-server/handleServerAction.client.d.ts

@@ -0,0 +1,11 @@
+import type { HandleWorkerServerActionFn } from "../react-client/types.js";
+/**
+ * Handles server action requests in the worker scenario.
+ *
+ * @param req - The incoming request
+ * @param res - The response object
+ * @param worker - The worker thread
+ * @param logger - The Vite logger
+ */
+export declare const handleServerAction: HandleWorkerServerActionFn;
+//# sourceMappingURL=handleServerAction.client.d.ts.map

package/dist/plugin/dev-server/handleServerAction.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleServerAction.client.d.ts","sourceRoot":"","sources":["../../../plugin/dev-server/handleServerAction.client.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,0BAA0B,CAAC;AAE3E;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,EAAE,0BAsG9B,CAAC"}

package/dist/plugin/dev-server/handleServerAction.client.js

@@ -0,0 +1,97 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { createServerActionStream, parseServerActionRequestBody, setupServerActionHeaders, handleServerActionError } from '../helpers/handleServerAction.js';
+import { cleanupServerAction } from './cleanupServerAction.client.js';
+
+const handleServerAction = async function _handleWorkerServerAction(req, res, worker, logger) {
+  let messageHandler = null;
+  const passThrough = createServerActionStream(res);
+  try {
+    const chunks = [];
+    for await (const chunk of req) {
+      chunks.push(chunk);
+    }
+    const body = Buffer.concat(chunks).toString();
+    const headerActionId = req.headers["x-rsc-action"];
+    const parsed = parseServerActionRequestBody(body, req.url);
+    const id = headerActionId || parsed.id;
+    const args = parsed.args;
+    setupServerActionHeaders(res);
+    worker.postMessage({
+      type: "SERVER_ACTION",
+      id,
+      args
+    });
+    messageHandler = (message) => {
+      try {
+        if (message.type === "RSC_CHUNK") {
+          passThrough.write(message.chunk);
+        } else if (message.type === "RSC_END") {
+          if (messageHandler) {
+            cleanupServerAction(passThrough, worker, messageHandler, res);
+          }
+        } else if (message.type === "SERVER_ACTION_RESPONSE") {
+          if (message.error?.message) {
+            logger.error(`[handleServerAction] Server action error: ${message.error?.message}`);
+            passThrough.write(`0:${JSON.stringify({ error: message.error.message })}
+`);
+          } else if (typeof message.error === "string") {
+            logger.error(`[handleServerAction] Server action error: ${message.error}`);
+            passThrough.write(`0:${JSON.stringify({ error: message.error })}
+`);
+          } else {
+            passThrough.write(`0:${JSON.stringify(message.result)}
+`);
+          }
+          if (messageHandler) {
+            cleanupServerAction(passThrough, worker, messageHandler, res);
+          }
+        } else if (message.type === "ERROR") {
+          if (messageHandler) {
+            cleanupServerAction(
+              passThrough,
+              worker,
+              messageHandler,
+              res,
+              message.error,
+              logger
+            );
+          }
+        }
+      } catch (error) {
+        logger.error(`[handleServerAction] Message handler error: ${error}`);
+        if (messageHandler) {
+          cleanupServerAction(
+            passThrough,
+            worker,
+            messageHandler,
+            res,
+            error,
+            logger
+          );
+        }
+      }
+    };
+    worker.on("message", messageHandler);
+    passThrough.on("error", (error) => {
+      if (messageHandler) {
+        cleanupServerAction(
+          passThrough,
+          worker,
+          messageHandler,
+          res,
+          error,
+          logger
+        );
+      }
+    });
+  } catch (error) {
+    handleServerActionError(error, res, logger);
+  }
+};
+
+export { handleServerAction };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"handleServerAction.client.js","sources":["../../../plugin/dev-server/handleServerAction.client.ts"],"sourcesContent":["import type {\n  RscChunkOutputMessage,\n  RscWorkerInputMessage,\n  RscWorkerOutputMessage,\n} from \"../worker/rsc/types.js\";\nimport {\n  parseServerActionRequestBody,\n  setupServerActionHeaders,\n  createServerActionStream,\n  handleServerActionError,\n} from \"../helpers/handleServerAction.js\";\nimport type { MessageHandler } from \"../types.js\";\nimport { cleanupServerAction } from \"./cleanupServerAction.client.js\";\nimport type { HandleWorkerServerActionFn } from \"../react-client/types.js\";\n\n/**\n * Handles server action requests in the worker scenario.\n *\n * @param req - The incoming request\n * @param res - The response object\n * @param worker - The worker thread\n * @param logger - The Vite logger\n */\nexport const handleServerAction: HandleWorkerServerActionFn =\n  async function _handleWorkerServerAction(req, res, worker, logger) {\n    let messageHandler: MessageHandler<RscChunkOutputMessage> | null = null;\n\n    const passThrough = createServerActionStream(res);\n    try {\n      // Read request body\n      const chunks: Buffer[] = [];\n      for await (const chunk of req) {\n        chunks.push(chunk);\n      }\n      const body = Buffer.concat(chunks).toString();\n\n      // Parse the server action request\n      // Get action ID from x-rsc-action header (React's standard) or fall back to body/URL\n      const headerActionId = req.headers[\"x-rsc-action\"] as string | undefined;\n      const parsed = parseServerActionRequestBody(body, req.url);\n      const id = headerActionId || parsed.id;\n      const args = parsed.args;\n\n      // Set up response headers\n      setupServerActionHeaders(res);\n\n      // Send server action request to worker\n      worker.postMessage({\n        type: \"SERVER_ACTION\",\n        id,\n        args,\n      } satisfies RscWorkerInputMessage);\n\n      // Create a pass-through stream for the response\n\n      // Handle worker messages with proper error handling\n      messageHandler = (message: RscWorkerOutputMessage & { error?: { message: string } }) => {\n        try {\n          if (message.type === \"RSC_CHUNK\") {\n            passThrough.write(message.chunk);\n          } else if (message.type === \"RSC_END\") {\n            if (messageHandler) {\n              cleanupServerAction(passThrough, worker, messageHandler, res);\n            }\n          } else if (message.type === \"SERVER_ACTION_RESPONSE\") {\n            // Server action completed - write result in RSC format and end stream\n            // RSC format: 0:<json-value>\\n\n            if (message.error?.message) {\n              logger.error(`[handleServerAction] Server action error: ${message.error?.message}`);\n              passThrough.write(`0:${JSON.stringify({ error: message.error.message })}\\n`);\n            } else if(typeof message.error === \"string\") {\n              logger.error(`[handleServerAction] Server action error: ${message.error}`);\n              passThrough.write(`0:${JSON.stringify({ error: message.error })}\\n`);\n            } else {\n              // Write the result directly - React will unwrap it\n              passThrough.write(`0:${JSON.stringify(message.result)}\\n`);\n            }\n            if (messageHandler) {\n              cleanupServerAction(passThrough, worker, messageHandler, res);\n            }\n          } else if (message.type === \"ERROR\") {\n            if (messageHandler) {\n              cleanupServerAction(\n                passThrough,\n                worker,\n                messageHandler,\n                res,\n                message.error,\n                logger\n              );\n            }\n          }\n        } catch (error) {\n          logger.error(`[handleServerAction] Message handler error: ${error}`);\n          if (messageHandler) {\n            cleanupServerAction(\n              passThrough,\n              worker,\n              messageHandler,\n              res,\n              error,\n              logger\n            );\n          }\n        }\n      };\n\n      worker.on(\"message\", messageHandler);\n\n      // Handle errors\n      passThrough.on(\"error\", (error: unknown) => {\n        if (messageHandler) {\n          cleanupServerAction(\n            passThrough,\n            worker,\n            messageHandler,\n            res,\n            error,\n            logger\n          );\n        }\n      });\n    } catch (error) {\n      handleServerActionError(error, res, logger);\n    }\n  };\n"],"names":[],"mappings":"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"}

package/dist/plugin/dev-server/handleServerAction.d.ts

@@ -0,0 +1,2 @@
+export declare const handleServerAction: any;
+//# sourceMappingURL=handleServerAction.d.ts.map

package/dist/plugin/dev-server/handleServerAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleServerAction.d.ts","sourceRoot":"","sources":["../../../plugin/dev-server/handleServerAction.ts"],"names":[],"mappings":"AAKA,eAAO,MAAQ,kBAAkB,KAEhC,CAAC"}

package/dist/plugin/dev-server/handleServerAction.js

@@ -0,0 +1,13 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { getCondition } from '../config/getCondition.js';
+
+const dir = new URL("./", import.meta.url).pathname.replace(/\/$/, "");
+const condition = getCondition("");
+const { handleServerAction } = await import(`${dir}/handleServerAction.${condition}.js`);
+
+export { handleServerAction };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFuZGxlU2VydmVyQWN0aW9uLmpzIiwic291cmNlcyI6WyIuLi8uLi8uLi9wbHVnaW4vZGV2LXNlcnZlci9oYW5kbGVTZXJ2ZXJBY3Rpb24udHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgZ2V0Q29uZGl0aW9uIH0gZnJvbSBcIi4uL2NvbmZpZy9nZXRDb25kaXRpb24uanNcIjtcblxuY29uc3QgZGlyID0gbmV3IFVSTChcIi4vXCIsIGltcG9ydC5tZXRhLnVybCkucGF0aG5hbWUucmVwbGFjZSgvXFwvJC8sIFwiXCIpO1xuY29uc3QgY29uZGl0aW9uID0gZ2V0Q29uZGl0aW9uKFwiXCIpO1xuXG5leHBvcnQgY29uc3QgeyBoYW5kbGVTZXJ2ZXJBY3Rpb24gfSA9IChhd2FpdCBpbXBvcnQoYCR7ZGlyfS9oYW5kbGVTZXJ2ZXJBY3Rpb24uJHtjb25kaXRpb259LmpzYCkpIGFzIHtcbiAgaGFuZGxlU2VydmVyQWN0aW9uOiBhbnk7XG59OyAiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7OztBQUVBLE1BQU0sR0FBQSxHQUFNLElBQUksR0FBQSxDQUFJLElBQU0sRUFBQSxNQUFBLENBQUEsSUFBQSxDQUFZLEdBQUcsQ0FBRSxDQUFBLFFBQUEsQ0FBUyxPQUFRLENBQUEsS0FBQSxFQUFPLEVBQUUsQ0FBQTtBQUNyRSxNQUFNLFNBQUEsR0FBWSxhQUFhLEVBQUUsQ0FBQTtBQUVwQixNQUFBLEVBQUUsb0JBQXdCLEdBQUEsTUFBTSxPQUFPLENBQUcsRUFBQSxHQUFHLHVCQUF1QixTQUFTLENBQUEsR0FBQSxDQUFBOzs7OyJ9

package/dist/plugin/dev-server/handleServerAction.server.d.ts

@@ -0,0 +1,3 @@
+import type { HandleServerActionFn } from "./types.js";
+export declare const handleServerAction: HandleServerActionFn;
+//# sourceMappingURL=handleServerAction.server.d.ts.map

package/dist/plugin/dev-server/handleServerAction.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handleServerAction.server.d.ts","sourceRoot":"","sources":["../../../plugin/dev-server/handleServerAction.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAMvD,eAAO,MAAM,kBAAkB,EAAE,oBAG9B,CAAC"}

package/dist/plugin/dev-server/handleServerAction.server.js

@@ -0,0 +1,15 @@
+/**
+ * vite-plugin-react-server
+ * Copyright (c) Nico Brinkkemper
+ * MIT License
+ */
+import { assertReactServer } from '../config/getCondition.js';
+import { handleServerActionWithViteServer } from '../helpers/handleServerAction.js';
+
+assertReactServer();
+const handleServerAction = async function _handleServerAction(req, res, server, handlerOptions) {
+  return handleServerActionWithViteServer(req, res, server, handlerOptions);
+};
+
+export { handleServerAction };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFuZGxlU2VydmVyQWN0aW9uLnNlcnZlci5qcyIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcGx1Z2luL2Rldi1zZXJ2ZXIvaGFuZGxlU2VydmVyQWN0aW9uLnNlcnZlci50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IEhhbmRsZVNlcnZlckFjdGlvbkZuIH0gZnJvbSBcIi4vdHlwZXMuanNcIjtcbmltcG9ydCB7IGFzc2VydFJlYWN0U2VydmVyIH0gZnJvbSBcIi4uL2NvbmZpZy9nZXRDb25kaXRpb24uanNcIjtcbmltcG9ydCB7IGhhbmRsZVNlcnZlckFjdGlvbldpdGhWaXRlU2VydmVyIH0gZnJvbSBcIi4uL2hlbHBlcnMvaGFuZGxlU2VydmVyQWN0aW9uLmpzXCI7XG5cbmFzc2VydFJlYWN0U2VydmVyKClcblxuZXhwb3J0IGNvbnN0IGhhbmRsZVNlcnZlckFjdGlvbjogSGFuZGxlU2VydmVyQWN0aW9uRm4gPVxuICBhc3luYyBmdW5jdGlvbiBfaGFuZGxlU2VydmVyQWN0aW9uKHJlcSwgcmVzLCBzZXJ2ZXIsIGhhbmRsZXJPcHRpb25zKSB7XG4gICAgcmV0dXJuIGhhbmRsZVNlcnZlckFjdGlvbldpdGhWaXRlU2VydmVyKHJlcSwgcmVzLCBzZXJ2ZXIsIGhhbmRsZXJPcHRpb25zKTtcbiAgfTtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7OztBQUlBLGlCQUFrQixFQUFBO0FBRVgsTUFBTSxxQkFDWCxlQUFlLG1CQUFBLENBQW9CLEdBQUssRUFBQSxHQUFBLEVBQUssUUFBUSxjQUFnQixFQUFBO0FBQ25FLEVBQUEsT0FBTyxnQ0FBaUMsQ0FBQSxHQUFBLEVBQUssR0FBSyxFQUFBLE1BQUEsRUFBUSxjQUFjLENBQUE7QUFDMUU7Ozs7In0=

package/dist/plugin/dev-server/index.client.d.ts

@@ -0,0 +1,7 @@
+export * from "./handleServerAction.client.js";
+export * from "./configureReactServer.client.js";
+export * from "./cleanupServerAction.client.js";
+export * from "./handleServerAction.client.js";
+export * from "./configureRequestHandler.client.js";
+export * from "./plugin.client.js";
+//# sourceMappingURL=index.client.d.ts.map

package/dist/plugin/dev-server/index.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.client.d.ts","sourceRoot":"","sources":["../../../plugin/dev-server/index.client.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qCAAqC,CAAC;AACpD,cAAc,oBAAoB,CAAC"}