vite-plugin-react-server 1.1.12 → 1.1.13

package/plugin/react-client/createWorkerStream.ts

@@ -7,6 +7,7 @@ import type { StreamMetrics } from "../types.js";
 import type { Worker as NodeWorker } from "node:worker_threads";
 import type { StreamHandlers } from "../worker/types.js";
 import { createMessageHandler } from "./createMessageHandlers.js";
+import { logError } from "../error/toError.js";
 
 /**
  * Creates an async generator that yields RSC chunks from the worker.
@@ -22,71 +23,108 @@ export async function* createWorkerStream({
   worker,
   message,
   logger,
-  handlers: { onHmrAccept, onHmrUpdate, onMetrics, onError, onData, onEnd },
+  handlers: {
+    onHmrAccept,
+    onHmrUpdate,
+    onMetrics,
+    onError,
+    onData,
+    onEnd,
+    onServerAction,
+    onServerActionResponse,
+  },
   verbose = false,
 }: {
   worker: NodeWorker;
-  message: Omit<RscRenderMessage, "type" | "id">;
+  message: Omit<RscRenderMessage, "type" | "id"> &
+    Partial<Pick<RscRenderMessage, "id">> & { type?: "RSC_RENDER" };
   logger: Logger;
   handlers: Pick<StreamHandlers, "onHmrAccept" | "onHmrUpdate" | "onMetrics"> &
-    Partial<Pick<StreamHandlers, "onError" | "onData" | "onEnd">>;
+    Partial<
+      Pick<
+        StreamHandlers,
+        | "onError"
+        | "onData"
+        | "onEnd"
+        | "onServerAction"
+        | "onServerActionResponse"
+      >
+    >;
   verbose?: boolean;
 }): AsyncGenerator<Uint8Array> {
+  if (!worker) {
+    throw new Error("Worker is not running");
+  }
   let messageHandler:
     | ((message: RscWorkerOutputMessage | undefined) => void)
     | null = null;
   let currentResolve: ((chunk: Uint8Array) => void) | null = null;
   const handlers: StreamHandlers = {
-    onError: (error: any, errorInfo?: any) => {
-      logger.error(
-        "[react-client] " +
-          (error.stack ?? error.stack.includes(error.message) ? "" : error.message + "\n") +
-          error.stack,
-        {
-          error,
-        }
-      );
+    onError: (id, error, errorInfo) => {
+      logError(error, logger);
       if (errorInfo) {
-        logger.error(errorInfo.componentStack);
+        logError(errorInfo.componentStack, logger);
       }
       if (typeof onError === "function") {
-        onError(error, errorInfo);
+        onError(id, error, errorInfo);
       }
     },
-    onData: (chunk: Uint8Array) => {
+    onData: (id: string, chunk: Uint8Array) => {
       currentResolve?.(chunk);
-      if (verbose) logger.info(`received chunk ${chunk.length} bytes`);
+      if (verbose) {
+        logger.info(
+          `[react-client] received chunk ${id} ${
+            Buffer.from(chunk).byteLength
+          } bytes`
+        );
+      }
       if (typeof onData === "function") {
-        onData(chunk);
+        onData(id, chunk);
       }
     },
-    onEnd: () => {
+    onEnd: (id: string) => {
       currentResolve?.(new Uint8Array());
-      if (verbose) logger.info(`received end`);
+      if (verbose) logger.info(`[react-client] received end`);
       if (messageHandler) {
         worker.removeListener("message", messageHandler);
         messageHandler = null;
       }
       if (typeof onEnd === "function") {
-        onEnd();
+        onEnd(id);
       }
     },
-    onMetrics: (metrics: StreamMetrics) => {
-      if (verbose) logger.info(`received chunks ${metrics.chunks}`);
+    onMetrics: (id: string, metrics: StreamMetrics) => {
+      if (verbose)
+        logger.info(`[react-client] received chunks ${metrics.chunks}`);
       if (typeof onMetrics === "function") {
-        onMetrics(metrics);
+        onMetrics(id, metrics);
       }
     },
-    onHmrAccept: (routes: string[]) => {
-      if (verbose) logger.info(`received hmr accept ${routes.join(", ")}`);
+    onHmrAccept: (id: string, routes?: string[]) => {
+      if (verbose)
+        logger.info(`[react-client] received hmr accept ${routes?.join(", ")}`);
       if (typeof onHmrAccept === "function") {
-        onHmrAccept(routes);
+        onHmrAccept(id, routes);
       }
     },
-    onHmrUpdate: (routes: string[]) => {
-      if (verbose) logger.info(`received hmr update ${routes.join(", ")}`);
+    onHmrUpdate: (id: string, routes?: string[]) => {
+      if (verbose)
+        logger.info(`[react-client] received hmr update ${routes?.join(", ")}`);
       if (typeof onHmrUpdate === "function") {
-        onHmrUpdate(routes);
+        onHmrUpdate(id, routes);
+      }
+    },
+    onServerAction: (id: string, args: unknown[]) => {
+      if (verbose) logger.info(`[react-client] received server action ${id}`);
+      if (typeof onServerAction === "function") {
+        onServerAction(id, args);
+      }
+    },
+    onServerActionResponse: (id: string, result?: unknown, error?: string) => {
+      if (verbose)
+        logger.info(`[react-client] received server action response ${id}`);
+      if (typeof onServerActionResponse === "function") {
+        onServerActionResponse(id, result, error);
       }
     },
   };
@@ -97,14 +135,14 @@ export async function* createWorkerStream({
       worker.removeListener("message", messageHandler);
       messageHandler = null;
     }
-    if (verbose) logger.info(`sending message RSC_RENDER`);
+    if (verbose) logger.info(`[react-client] sending message RSC_RENDER`);
     worker.postMessage({
       ...message,
       type: "RSC_RENDER",
-      id: Math.random().toString(36).slice(2),
+      id: message?.id ?? message.route,
     });
 
-    if (verbose) logger.info(`waiting for message handler`);
+    if (verbose) logger.info(`[react-client] waiting for message handler`);
     let workerTimeout: NodeJS.Timeout | null = null;
     yield await new Promise<Uint8Array>((resolve) => {
       workerTimeout = setTimeout(() => {
@@ -122,7 +160,7 @@ export async function* createWorkerStream({
     if (workerTimeout) {
       clearTimeout(workerTimeout);
     }
-    if (verbose) logger.info(`received message handler`);
+    if (verbose) logger.info(`[react-client] received message handler`);
     while (true) {
       const chunk = await new Promise<Uint8Array>((resolve) => {
         currentResolve = resolve;

package/plugin/react-client/handleWorkerRscStream.ts

@@ -21,7 +21,7 @@ export function handleWorkerRscStream({
   message: Omit<RscRenderMessage, "type" | "id">,
   logger: Logger,
   handlers: Pick<StreamHandlers, "onMetrics" | "onHmrAccept" | "onHmrUpdate"> &
-    Partial<Pick<StreamHandlers, "onError" | "onData" | "onEnd">>,
+    Partial<Pick<StreamHandlers, "onError" | "onData" | "onEnd" | "onServerAction" | "onServerActionResponse">>,
   verbose?: boolean
 }): ReadableStream<Uint8Array> {
   // Create a ReadableStream from the async generator
@@ -29,17 +29,27 @@ export function handleWorkerRscStream({
   return new ReadableStream<Uint8Array>({
     async start(controller) {
       try {
-        if(verbose) logger.info("Starting stream");
+        if(verbose) logger.info("[react-client] Starting stream");
         for await (const chunk of createWorkerStream({
           worker,
           message,
           logger,
-          handlers,
+          handlers: {
+            ...handlers,
+            onServerAction: (id: string, args: unknown[]) => {
+              if (verbose) logger.info(`[react-client] Received server action ${id}`);
+              handlers.onServerAction?.(id, args);
+            },
+            onServerActionResponse: (id: string, result?: unknown, error?: string) => {
+              if (verbose) logger.info(`[react-client] Received server action response ${id}`);
+              handlers.onServerActionResponse?.(id, result, error);
+            }
+          },
           verbose
         })) {
           if (!isFlowing) {
             isFlowing = true;
-            if(verbose) logger.info("Stream is flowing");
+            if(verbose) logger.info("[react-client] Stream is flowing");
           }
           controller.enqueue(chunk);
         }
@@ -48,7 +58,7 @@ export function handleWorkerRscStream({
       } finally {
         if (isFlowing) {
           isFlowing = false;
-          if(verbose) logger.info("Stream closing");
+          if(verbose) logger.info("[react-client] Stream closing");
         }
         controller.close();
       }

package/plugin/react-client/plugin.ts

@@ -1,6 +1,8 @@
 import { type ConfigEnv, type Plugin } from "vite";
 import type {
   AutoDiscoveredFiles,
+  InlineCssOpt,
+  PagePropOpt,
   ResolvedUserConfig,
   ResolvedUserOptions,
   StreamPluginOptions,
@@ -8,18 +10,21 @@ import type {
 import { resolveOptions } from "../config/resolveOptions.js";
 import { resolveUserConfig } from "../config/resolveUserConfig.js";
 import { resolveAutoDiscover } from "../config/autoDiscover/resolveAutoDiscover.js";
-import { configureWorkerRequestHandler } from "./server.js";
+import { configureWorkerRequestHandler } from "./configureWorkerRequestHandler.js";
 import { configurePreviewServer } from "../react-static/configurePreviewServer.js";
 import { MessageChannel } from "node:worker_threads";
 
-let userOptions: ResolvedUserOptions;
-let userConfig: ResolvedUserConfig;
-let configEnv: ConfigEnv;
-let root: string;
-let autoDiscoveredFiles: AutoDiscoveredFiles;
-let hmrChannel: MessageChannel | null = null;
+export function reactClientPlugin<
+  T extends PagePropOpt = PagePropOpt,
+  InlineCSS extends InlineCssOpt = InlineCssOpt
+>(options: StreamPluginOptions<T, InlineCSS>): Plugin {
+  let userOptions: ResolvedUserOptions<T, InlineCSS>;
+  let userConfig: ResolvedUserConfig;
+  let configEnv: ConfigEnv;
+  let root: string;
+  let autoDiscoveredFiles: AutoDiscoveredFiles;
+  let hmrChannel: MessageChannel | null = null;
 
-export function reactClientPlugin(options: StreamPluginOptions): Plugin {
   const resolvedOptions = resolveOptions(options);
   if (resolvedOptions.type === "error") {
     throw resolvedOptions.error;
@@ -53,7 +58,7 @@ export function reactClientPlugin(options: StreamPluginOptions): Plugin {
       }
       autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles;
 
-      const resolvedConfig = resolveUserConfig({
+      const resolvedConfig = resolveUserConfig<T, InlineCSS>({
         condition: "react-client",
         config,
         configEnv,
@@ -66,10 +71,10 @@ export function reactClientPlugin(options: StreamPluginOptions): Plugin {
       }
 
       userConfig = resolvedConfig.userConfig;
-      return userConfig
+      return userConfig;
     },
     async configurePreviewServer(server) {
-      await configurePreviewServer({
+      await configurePreviewServer<T, InlineCSS>({
         server,
         userOptions,
       });
@@ -92,7 +97,7 @@ export function reactClientPlugin(options: StreamPluginOptions): Plugin {
     async configureServer(server) {
       // Create HMR message channel
       hmrChannel = new MessageChannel();
-      await configureWorkerRequestHandler({
+      await configureWorkerRequestHandler<T, InlineCSS>({
         server,
         autoDiscoveredFiles,
         userOptions,
@@ -112,7 +117,7 @@ export function reactClientPlugin(options: StreamPluginOptions): Plugin {
 
         // Find all routes affected by this file change
         const affectedRoutes = autoDiscoveredFiles.routeMap.get(value) || [];
-        console.log({affectedRoutes})
+
         // Send HMR update directly to worker through MessageChannel
         if (hmrChannel?.port1) {
           hmrChannel.port1.postMessage({

package/plugin/react-client/restartWorker.ts

@@ -5,7 +5,7 @@ import type { AutoDiscoveredFiles } from "../../types.js";
 import { createWorker } from "../worker/createWorker.js";
 import { serializedDevServerConfig } from "../helpers/serializeUserOptions.js";
 import { serializedOptions } from "../helpers/serializeUserOptions.js";
-import type { MessageChannel, Worker } from "node:worker_threads";
+import { MessageChannel, type Worker } from "node:worker_threads";
 import { DEFAULT_CONFIG } from "../config/defaults.js";
 
 let currentWorker: Worker | null = null;
@@ -23,7 +23,7 @@ export async function restartWorker({
     hmrChannel: MessageChannel,
   }) {
     if (isRestarting) {
-      throw new Error('Worker is restarting')
+      return currentWorker;
     }
     isRestarting = true;
   
@@ -33,9 +33,19 @@ export async function restartWorker({
         currentWorker.removeAllListeners();
         currentWorker = null;
       }
+      
       const routeCount = autoDiscoveredFiles.urlMap.size;
       const hmrBuffer = 20; // Buffer for HMR and other operations
       const maxListeners = routeCount + hmrBuffer;
+
+      // Create a new MessageChannel for this worker
+      const workerHmrChannel = new MessageChannel();
+      
+      // Forward messages from the plugin's HMR channel to the worker's channel
+      hmrChannel.port1.addEventListener('message', (event: Event) => {
+        workerHmrChannel.port1.postMessage((event as MessageEvent).data);
+      });
+      
       const workerResult = await createWorker({
         projectRoot: server.config.root,
         workerPath: userOptions.rscWorkerPath,
@@ -49,11 +59,11 @@ export async function restartWorker({
             ? server.config.envPrefix[0]
             : DEFAULT_CONFIG.ENV_PREFIX,
         workerData: {
-          hmrPort: hmrChannel.port2,
+          hmrPort: workerHmrChannel.port2,
           resolvedConfig: serializedDevServerConfig(server.config),
           userOptions: serializedOptions(userOptions, autoDiscoveredFiles),
         },
-        transferList: [hmrChannel.port2],
+        transferList: [workerHmrChannel.port2],
       });
   
       if (workerResult.type === "success") {
@@ -65,9 +75,11 @@ export async function restartWorker({
         server.config.logger.error("Failed to start rsc-worker", {
           error: workerResult.error,
         });
+        throw workerResult.error;
       }
     } finally {
       isRestarting = false;
     }
+   
     return currentWorker;
-  }
+}

package/plugin/react-server/{server.ts → configureReactServer.ts}

@@ -1,6 +1,11 @@
 import type { Manifest, ViteDevServer } from "vite";
 import type { ServerResponse } from "http";
-import type { AutoDiscoveredFiles, ResolvedUserOptions } from "../types.js";
+import type {
+  AutoDiscoveredFiles,
+  InlineCssOpt,
+  PagePropOpt,
+  ResolvedUserOptions,
+} from "../types.js";
 import { createEventHandler } from "../helpers/createEventHandler.js";
 import { collectViteModuleGraphCss } from "../helpers/collectViteModuleGraphCss.js";
 import { resolvePageAndProps } from "../helpers/resolvePageAndProps.js";
@@ -8,9 +13,13 @@ import { createHandler } from "../helpers/createHandler.js";
 import React from "react";
 import { requestInfo } from "../helpers/requestInfo.js";
 import { getRouteFiles } from "../helpers/getRouteFiles.js";
-import { toError } from "../error/toError.js";
+import { logError } from "../error/toError.js";
+import { handleServerAction } from "./handleServerAction.js";
 
-export async function configureReactServer({
+export async function configureReactServer<
+  T extends PagePropOpt = PagePropOpt,
+  InlineCSS extends InlineCssOpt = InlineCssOpt
+>({
   server,
   autoDiscoveredFiles,
   userOptions: _userOptions,
@@ -18,7 +27,7 @@ export async function configureReactServer({
 }: {
   server: ViteDevServer;
   autoDiscoveredFiles: AutoDiscoveredFiles;
-  userOptions: ResolvedUserOptions;
+  userOptions: ResolvedUserOptions<T, InlineCSS>;
   serverManifest: Manifest;
 }) {
   const activeStreams = new Set<ServerResponse>();
@@ -30,10 +39,26 @@ export async function configureReactServer({
     projectRoot: _projectRoot,
     ...handlerUserOptions
   } = _userOptions;
-  const handlerOptions = Object.assign({}, handlerUserOptions, {
+  const handlerOptions = {
+    ...handlerUserOptions,
     moduleBaseURL: server.config.base,
     projectRoot: server.config.root,
-  });
+    Html: React.Fragment,
+    onEvent: createEventHandler(onEvent),
+    css: handlerUserOptions.css
+  };
+
+  // Set environment-specific configuration
+  const define = {
+    ...server.config.define,
+    "process.env.NODE_ENV": JSON.stringify(
+      process.env["NODE_ENV"] || "development"
+    ),
+  };
+  server.config = {
+    ...server.config,
+    define,
+  };
 
   // Handle Vite server restarts
   server.ws.on("restart", (path) => {
@@ -59,7 +84,13 @@ export async function configureReactServer({
     if (!req.url) {
       return next();
     }
-    const info = requestInfo(req, handlerOptions, "");
+    const info = requestInfo(req, handlerOptions, "", server.config.logger);
+
+    // Handle server actions
+    if (info.isServerActionRequest) {
+      return handleServerAction(req, res, server, handlerOptions);
+    }
+
     if (!info.isRscRequest) return next();
     try {
       const routeFiles = await getRouteFiles(
@@ -109,7 +140,7 @@ export async function configureReactServer({
       }
       const { PageComponent, pageProps } = pageAndPropsResult;
       // Create the headless RSC stream directly;
-      const rscResult = await createHandler({
+      const rscResult = createHandler({
         ...handlerOptions,
         PageComponent: PageComponent,
         pageProps: pageProps,
@@ -135,7 +166,7 @@ export async function configureReactServer({
         activeStreams.delete(res);
       });
     } catch (error) {
-      server.config.logger.error(toError(error).message);
+      logError(error, server.config.logger);
       res.end();
     }
   });

package/plugin/react-server/handleServerAction.ts

@@ -0,0 +1,177 @@
+import type { ViteDevServer } from "vite";
+import type {
+  InlineCssOpt,
+  PagePropOpt,
+  ResolvedUserOptions,
+} from "../types.js";
+import { logError, toError } from "../error/toError.js";
+import { join } from "path";
+import { ReactDOMServer } from "../vendor/vendor.server.js";
+import type { IncomingMessage, ServerResponse } from "http";
+
+export async function handleServerAction<
+  T extends PagePropOpt,
+  InlineCss extends InlineCssOpt
+>(
+  req: IncomingMessage,
+  res: ServerResponse,
+  server: ViteDevServer,
+  handlerOptions: ResolvedUserOptions<T, InlineCss>
+) {
+  try {
+    if (handlerOptions.verbose) {
+      server.config.logger.info(
+        `[react-server] Handling server action request at ${req.url}`
+      );
+    }
+
+    // Parse the request body - handle both formats:
+    // 1. Direct args array: ["arg1", "arg2"]
+    // 2. Object with id and args: { id: "path/to/action", args: ["arg1", "arg2"] }
+    let id: string;
+    let args: unknown[];
+    try {
+      const chunks: Buffer[] = [];
+      for await (const chunk of req) {
+        chunks.push(chunk);
+      }
+      const body = Buffer.concat(chunks).toString();
+      if (handlerOptions.verbose) {
+        server.config.logger.info(`[react-server] Request body: ${body}`);
+      }
+
+      const parsed = JSON.parse(body);
+      if (Array.isArray(parsed)) {
+        // Format 1: Direct args array
+        args = parsed;
+        // Get the action ID from the request URL
+        id = req.url?.split("?")[0] ?? "";
+        if (handlerOptions.verbose) {
+          server.config.logger.info(
+            `[react-server] Using action ID from URL: ${id}`
+          );
+        }
+      } else if (parsed && typeof parsed === "object" && "id" in parsed) {
+        // Format 2: Object with id and args
+        id = parsed.id;
+        args = parsed.args ?? [];
+      } else {
+        throw new Error("Invalid server action request format");
+      }
+    } catch (error: unknown) {
+      const err = toError(error);
+      throw new Error(`Failed to parse server action request`, {
+        cause: err,
+      });
+    }
+
+    if (!id) {
+      throw new Error("Server action ID is required");
+    }
+
+    if (handlerOptions.verbose) {
+      server.config.logger.info(
+        `[react-server] Server action request for ${id} with args: ${JSON.stringify(
+          args
+        )}`
+      );
+    }
+
+    // Parse the server action ID to get the file path and export name
+    const [filePath, exportName] = id.split("#");
+    if (!filePath || !exportName) {
+      throw new Error(
+        `Invalid server action ID format: ${id}. Expected format: "path/to/file.ts#exportName"`
+      );
+    }
+
+    // Convert the server action ID to a file path
+    const actionPath = filePath.startsWith("/") ? filePath.slice(1) : filePath;
+    const fullPath = join(handlerOptions.projectRoot, actionPath);
+    if (handlerOptions.verbose) {
+      server.config.logger.info(
+        `[react-server] Resolved file path: id=${id}, actionPath=${actionPath}, projectRoot=${handlerOptions.projectRoot}, filePath=${fullPath}, exportName=${exportName}`
+      );
+    }
+
+    // Load the server action module
+    if (handlerOptions.verbose) {
+      server.config.logger.info(`[react-server] Loading module: ${fullPath}`);
+    }
+    const module = await server.ssrLoadModule(fullPath);
+    if (handlerOptions.verbose) {
+      server.config.logger.info(
+        `[react-server] Looking for action: ${exportName} in module with exports: ${Object.keys(
+          module
+        ).join(", ")}`
+      );
+    }
+    const action = module[exportName];
+
+    if (typeof action !== "function") {
+      if (handlerOptions.verbose) {
+        server.config.logger.error(
+          `[react-server] Action not found: ${exportName} in module with exports: ${Object.keys(
+            module
+          ).join(", ")}`
+        );
+      }
+      throw new Error(`Server action not found: ${id}`);
+    }
+
+    // Execute the server action
+    if (handlerOptions.verbose) {
+      server.config.logger.info(
+        `[react-server] Executing action with args: ${JSON.stringify(args)}`
+      );
+    }
+    const result = await action(...args);
+    if (handlerOptions.verbose) {
+      server.config.logger.info(
+        `[react-server] Action completed successfully with result: ${JSON.stringify(
+          result
+        )}`
+      );
+    }
+
+    // Send the response
+    res.setHeader("Content-Type", "text/x-component; charset=utf-8");
+
+    const { pipe } = ReactDOMServer.renderToPipeableStream(
+      {
+        type: "server-action-response",
+        returnValue: result,
+      },
+      handlerOptions.moduleBasePath,
+      {
+        onError(error: Error) {
+          logError(error, server.config.logger);
+          res.statusCode = 500;
+          res.end();
+        },
+      }
+    );
+
+    pipe(res);
+  } catch (error) {
+    logError(error, server.config.logger);
+    res.statusCode = 500;
+    res.setHeader("Content-Type", "text/x-component; charset=utf-8");
+
+    const { pipe } = ReactDOMServer.renderToPipeableStream(
+      {
+        type: "server-action-response",
+        error: toError(error).message,
+      },
+      handlerOptions.moduleBasePath,
+      {
+        onError(error: Error) {
+          logError(error, server.config.logger);
+          res.end();
+        },
+      }
+    );
+
+    pipe(res);
+  }
+}

package/plugin/react-server/plugin.ts

@@ -13,13 +13,15 @@ import type {
   BuildTiming,
   ReactStreamPluginMeta,
   ResolvedUserOptions,
+  PagePropOpt,
+  InlineCssOpt,
 } from "../types.js";
 import { type StreamPluginOptions } from "../types.js";
 import {
   resolveAutoDiscover
 } from "../config/autoDiscover/resolveAutoDiscover.js";
 import { getCondition } from "../config/getCondition.js";
-import { configureReactServer } from "./server.js";
+import { configureReactServer } from "./configureReactServer.js";
 import { configurePreviewServer } from "../react-static/configurePreviewServer.js";
 import { getBundleManifest } from "../helpers/getBundleManifest.js";
 
@@ -31,7 +33,10 @@ if (getCondition() !== "react-server") {
       process.env["NODE_OPTIONS"]
   );
 }
-export function reactServerPlugin(options: StreamPluginOptions): VitePlugin<{
+export function reactServerPlugin<
+  T extends PagePropOpt = PagePropOpt,
+  InlineCSS extends InlineCssOpt = InlineCssOpt
+>(options: StreamPluginOptions<T, InlineCSS>): VitePlugin<{
   meta: ReactStreamPluginMeta;
 }> {
   const timing: BuildTiming = {
@@ -39,7 +44,7 @@ export function reactServerPlugin(options: StreamPluginOptions): VitePlugin<{
   };
 
   let autoDiscoveredFiles: AutoDiscoveredFiles;
-  let userOptions: ResolvedUserOptions;
+  let userOptions: ResolvedUserOptions<T, InlineCSS>;
   let serverManifest: Manifest = {};
 
   const resolvedOptions = resolveOptions(options);