vite-plugin-react-server
Version:
Vite plugin for React Server Components (RSC)
715 lines (713 loc) • 106 kB
JavaScript
/**
* vite-plugin-react-server
* Copyright (c) Nico Brinkkemper
* MIT License
*/
import { createLogger } from 'vite';
import { resolveOptions } from '../config/resolveOptions.js';
import { renderPagesBatched } from './renderPagesBatched.js';
import { performance } from 'node:perf_hooks';
import { renderPage } from './renderPage.client.js';
import { createWorker } from '../worker/createWorker.js';
import { serializeResolvedConfig, serializedOptions } from '../helpers/serializeUserOptions.js';
import { getBundleManifest } from '../helpers/getBundleManifest.js';
import { handleError } from '../error/handleError.js';
import { shouldCausePanic } from '../error/panicThresholdHandler.js';
import { configurePreviewServer } from './configurePreviewServer.js';
import { assertNonReactServer } from '../config/getCondition.js';
import { envPrefixFromConfig } from '../config/envPrefixFromConfig.js';
import { createWorkerStartupMetrics } from '../metrics/createWorkerStartupMetrics.js';
import { processCssFilesForPages } from './processCssFilesForPages.js';
import { createBuildLoader } from './createBuildLoader.client.js';
import { getNodeEnv } from '../config/getNodeEnv.js';
import { toError } from '../error/toError.js';
import { addStaticManifest, manifests, getSharedManifestStore } from '../bundle/manifests.js';
import { deferStaticGeneration } from '../bundle/deferredStaticGeneration.js';
import { resolveAutoDiscover } from '../config/autoDiscover/resolveAutoDiscover.js';
import { join } from 'node:path';
import { baseURL } from '../utils/envUrls.node.js';
import { tryManifest } from '../helpers/tryManifest.js';
assertNonReactServer();
const reactStaticPlugin = function _reactStaticPlugin(options) {
let logger;
let autoDiscoveredFiles = null;
let rscWorker = void 0;
let resolvedConfig = null;
let serverManifest = void 0;
let staticBundle = void 0;
let serverBundle = void 0;
let configEnv;
const timing = {
start: performance.now(),
configResolved: 0,
buildStart: 0,
renderStart: 0
};
const resolvedOptions = resolveOptions(options);
if (resolvedOptions.type === "error") {
throw resolvedOptions.error;
}
const userOptions = resolvedOptions.userOptions;
return {
name: "vite:plugin-react-server/client-static",
enforce: "post",
apply: "build",
// Apply to build mode
api: {
meta: { timing }
},
async config(_config, viteConfigEnv) {
configEnv = viteConfigEnv;
},
applyToEnvironment(partialEnvironment) {
const envName = partialEnvironment.name;
if (["static", "client"].includes(envName)) {
return true;
}
return false;
},
async configResolved(config) {
timing.configResolved = performance.now();
logger = config.customLogger || createLogger();
resolvedConfig = config;
const autoDiscoverResult = await resolveAutoDiscover({
config,
configEnv: configEnv || {
mode: config.mode,
command: config.command},
userOptions,
logger
});
if (autoDiscoverResult.type === "error") {
throw autoDiscoverResult.error;
}
autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles;
if (userOptions.verbose) {
logger?.info(`Auto-discovery ${autoDiscoverResult.type === "success" ? "completed" : "skipped"}`);
}
},
async buildStart() {
timing.buildStart = performance.now();
if (userOptions.verbose) {
logger?.info("[react-static-client] Build started");
}
if (userOptions.onEvent && autoDiscoveredFiles) {
try {
userOptions.onEvent({
type: "build.start",
data: {
pages: Array.from(autoDiscoveredFiles.urlMap.keys()),
files: autoDiscoveredFiles
}
});
} catch (error) {
const panicError = handleError({
error,
logger,
panicThreshold: userOptions.panicThreshold});
if (panicError != null) {
rscWorker?.terminate();
throw panicError;
}
}
}
},
async renderStart() {
timing.renderStart = performance.now();
if (userOptions.verbose) {
logger?.info("[react-static-client] Render started");
}
},
// the preview server helps to view the generated static folder, but only when the static plugin is enabled
// if no build.pages, then the preview server will instead use default vite preview server
// it works the same under both conditions
async configurePreviewServer(server) {
logger = server.config.customLogger || server.config.logger;
configurePreviewServer({
server,
userOptions
});
},
async writeBundle(_options, bundle) {
try {
if (!autoDiscoveredFiles?.urlMap) {
return;
}
const bundleManifest = getBundleManifest({
bundle,
normalizer: userOptions.normalizer
});
if (this.environment.name === "static") {
addStaticManifest(bundleManifest);
staticBundle = bundle;
} else if (this.environment.name === "client") {
if (manifests.static) {
const staticManifest = manifests.static;
for (const [, chunk] of Object.entries(bundle)) {
if (chunk.type === "chunk" && chunk.fileName) {
const normalized = userOptions.normalizer(chunk.fileName);
let value = normalized[1];
if (value.startsWith(userOptions.moduleBasePath)) {
value = value.slice(userOptions.moduleBasePath.length);
}
const entry = staticManifest[value];
if (entry && entry.file !== chunk.fileName) {
chunk.fileName = entry.file;
}
}
}
}
} else if (this.environment.name === "server") {
serverBundle = bundle;
}
return;
} catch (error) {
const panicError = handleError({
error,
logger,
panicThreshold: userOptions.panicThreshold});
if (panicError != null) {
throw panicError;
}
}
},
async closeBundle() {
const envName = this.environment.name;
const isSsr = this.environment.config.build?.ssr === true;
if (userOptions.verbose) {
logger?.info(`[react-static-client] closeBundle called for environment: ${envName}, ssr: ${isSsr}`);
}
if (envName === "ssr" || envName === "server" || isSsr) {
if (userOptions.verbose) {
logger?.info(`[react-static-client] Skipping static generation for environment: ${envName} (ssr: ${isSsr})`);
}
return;
}
if (envName === "static" || envName === "client" && !isSsr) {
try {
const { rmSync, existsSync } = await import('node:fs');
const { join: join2, resolve } = await import('node:path');
const resolvedOutDir = this.environment.config.build?.outDir ? resolve(this.environment.config.root || userOptions.projectRoot, this.environment.config.build.outDir) : resolve(userOptions.projectRoot, userOptions.build.outDir);
const outputDirs = [
join2(resolvedOutDir, userOptions.build.static || "static"),
join2(resolvedOutDir, userOptions.build.client || "client")
];
for (const outDir of outputDirs) {
const virtualDir = join2(outDir, "_virtual");
if (existsSync(virtualDir)) {
rmSync(virtualDir, { recursive: true, force: true });
if (userOptions.verbose) {
logger?.info(`[react-static-client] Cleaned up _virtual directory: ${virtualDir}`);
}
}
}
} catch (error) {
if (userOptions.verbose) {
logger?.warn(`[react-static-client] Failed to clean up _virtual directory: ${error}`);
}
}
}
if (envName === "ssr" || envName === "server" || isSsr) {
if (userOptions.verbose) {
logger?.info(`[react-static-client] Skipping static generation - not in static environment (${envName}, ssr: ${isSsr})`);
}
return;
}
const closeBundleContext = this;
deferStaticGeneration(async () => {
try {
if (!autoDiscoveredFiles) {
if (userOptions.verbose) {
logger?.warn("[react-static-client] autoDiscoveredFiles not set, attempting to re-discover");
}
const { getStashedUserOptions, getEnvironmentId } = await import('../config/stashedOptionsState.js');
const { getCondition } = await import('../config/getCondition.js');
const envId = getEnvironmentId(getCondition(), resolvedConfig?.mode || "production");
const stashedOptions = getStashedUserOptions(envId);
if (stashedOptions && resolvedConfig) {
const autoDiscoverResult = await resolveAutoDiscover({
config: resolvedConfig,
configEnv: configEnv || {
mode: resolvedConfig.mode || "production",
command: resolvedConfig.command || "build",
isSsrBuild: false,
isPreview: false
},
userOptions,
logger
});
if (autoDiscoverResult.type === "success") {
autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles;
if (userOptions.verbose) {
logger?.info(`[react-static-client] Re-discovered ${autoDiscoveredFiles.urlMap.size} pages`);
}
} else {
if (userOptions.verbose) {
logger?.warn(`[react-static-client] Failed to re-discover pages: ${autoDiscoverResult.error}`);
}
}
}
}
if (!autoDiscoveredFiles?.urlMap || autoDiscoveredFiles?.urlMap.size === 0) {
if (userOptions.verbose) {
logger?.warn(`[react-static-client] No pages to generate - urlMap is empty (size: ${autoDiscoveredFiles?.urlMap?.size || 0})`);
logger?.warn(`[react-static-client] autoDiscoveredFiles exists: ${!!autoDiscoveredFiles}, urlMap exists: ${!!autoDiscoveredFiles?.urlMap}`);
}
return;
}
if (userOptions.verbose) {
logger?.info(`[react-static-client] Starting static generation with ${autoDiscoveredFiles.urlMap.size} pages`);
}
try {
if (userOptions.verbose) {
logger?.info(`[react-static-client] Attempting to get server manifest from shared state`);
}
const sharedState = getSharedManifestStore(closeBundleContext);
if (sharedState.server) {
serverManifest = sharedState.server;
if (userOptions.verbose) {
logger?.info(`[react-static-client] Got server manifest from shared state`);
}
} else {
throw new Error("No server manifest in shared state");
}
} catch (error) {
if (userOptions.verbose) {
logger?.info(`[react-static-client] Failed to get server manifest from shared state, trying filesystem: ${error}`);
}
const serverManifestPath = join(
userOptions.build.outDir,
userOptions.build.server
);
const manifestPath = typeof resolvedConfig?.build.manifest === "string" ? resolvedConfig.build.manifest : ".vite/manifest.json";
if (userOptions.verbose) {
logger?.info(`[react-static-client] Loading server manifest from: ${join(serverManifestPath, manifestPath)}`);
}
const serverManifestResult = await tryManifest({
root: userOptions.projectRoot,
outDir: serverManifestPath,
manifestPath,
ssrManifest: false
});
if (serverManifestResult.type === "error") {
if (userOptions.verbose) {
logger?.warn(`[react-static-client] Failed to load server manifest: ${serverManifestResult.error}`);
}
serverManifest = {};
if (userOptions.verbose) {
logger?.warn(`[react-static-client] Using empty server manifest as fallback`);
}
} else if (serverManifestResult.type === "skip") {
if (userOptions.verbose) {
logger?.warn(`[react-static-client] Server manifest not found, using empty manifest as fallback`);
}
serverManifest = {};
} else {
serverManifest = serverManifestResult.manifest;
if (userOptions.verbose) {
logger?.info(`[react-static-client] Loaded server manifest from filesystem`);
}
}
}
const staticManifestResult = await tryManifest({
root: userOptions.projectRoot,
outDir: join(userOptions.build.outDir, userOptions.build.static),
manifestPath: resolvedConfig?.build.manifest ?? ".vite/manifest.json",
ssrManifest: false
});
if (staticManifestResult.type === "error") {
throw staticManifestResult.error;
}
const staticManifest = staticManifestResult.manifest;
const indexHtml = staticManifest?.["index.html"]?.file;
const serverPipeableStreamOptions = {
...userOptions.serverPipeableStreamOptions,
bootstrapModules: [
...indexHtml ? [baseURL(indexHtml)] : [],
...userOptions.serverPipeableStreamOptions?.bootstrapModules ?? []
]
};
userOptions.serverPipeableStreamOptions = serverPipeableStreamOptions;
const clientPipeableStreamOptions = {
...userOptions.clientPipeableStreamOptions,
bootstrapModules: [
...indexHtml ? [baseURL(indexHtml)] : [],
...userOptions.clientPipeableStreamOptions?.bootstrapModules ?? []
]
};
const { cssFilesByPage, globalCss } = processCssFilesForPages({
userOptions,
autoDiscoveredFiles,
serverManifest,
staticManifest,
bundle: staticBundle || {},
logger
});
if (userOptions.verbose) {
for (const [route, cssMap] of cssFilesByPage.entries()) {
logger.info(
`[react-static-client] Route ${route}: ${cssMap.size} CSS files`
);
for (const [key, value] of cssMap.entries()) {
logger.info(
`[react-static-client] CSS file: ${key} -> ${value.as} (${value.children ? "inline" : "link"})`
);
}
}
}
const routes = Array.from(
autoDiscoveredFiles.urlMap.keys()
);
if (routes.length === 0) {
if (userOptions.verbose) {
logger?.info(
"[react-static-client] No pages to generate, skipping static generation"
);
}
return;
}
if (userOptions.verbose) {
logger?.info(`[react-static-client] Creating build loader`);
}
const buildLoader = createBuildLoader();
if (userOptions.verbose) {
logger?.info(`[react-static-client] Build loader created`);
}
if (userOptions.verbose) {
logger?.info(
`[react-static-client] Creating RSC worker with path: ${userOptions.rscWorkerPath}`
);
}
const workerStartTime = performance.now();
let rscWorkerResult;
try {
rscWorkerResult = await createWorker({
projectRoot: userOptions.projectRoot,
workerPath: userOptions.rscWorkerPath,
currentCondition: "react-client",
reverseCondition: "react-server",
maxListeners: Math.max(routes.length * 3, 10),
// Account for multiple listeners per route
envPrefix: envPrefixFromConfig(resolvedConfig),
logger,
verbose: userOptions.verbose,
mode: getNodeEnv(),
workerData: {
userOptions: serializedOptions(userOptions, autoDiscoveredFiles),
resolvedConfig: serializeResolvedConfig(resolvedConfig),
configEnv: (() => {
const fallback = resolvedConfig ? {
command: resolvedConfig.command,
mode: resolvedConfig.mode,
isSsrBuild: false,
isPreview: false
} : void 0;
const finalConfigEnv = configEnv || fallback;
return finalConfigEnv;
})(),
serverManifest: serverManifest || {},
// Use server manifest for page component resolution
bundle: staticBundle || {},
// Use static bundle (client build) for page component resolution
staticBundle: staticBundle || {},
// Pass static bundle separately for path resolution
id: "static-client-rsc-worker"
}
});
} catch (workerError) {
if (userOptions.verbose) {
logger?.error(`[react-static-client] Error creating RSC worker: ${workerError}`);
}
throw workerError;
}
if (rscWorkerResult.type !== "success") {
const err = rscWorkerResult.error ?? new Error(`Failed to create RSC worker`);
if (userOptions.verbose) {
logger?.error(
`[react-static-client] RSC worker creation failed, throwing error`,
{ error: err }
);
}
throw err;
}
rscWorker = rscWorkerResult.worker;
if (userOptions.verbose) {
logger?.info(`[react-static-client] RSC worker created successfully`);
}
const workerStartupTime = performance.now() - workerStartTime;
if (userOptions.onMetrics) {
const workerStartupMetric = createWorkerStartupMetrics({
route: "/",
// Worker startup is global, not route-specific
workerType: "rsc",
// This is the RSC worker for client-side static generation
startupTime: workerStartupTime,
fromMainThread: true,
fromRscWorker: false,
fromHtmlWorker: false,
description: `RSC worker startup for client-side static generation`
});
userOptions.onMetrics(workerStartupMetric);
}
const { onEvent, onMetrics, ...handlerOptions } = userOptions;
if (userOptions.verbose) {
logger?.info(`[react-static-client] Extracted onEvent: ${typeof onEvent}, userOptions.onEvent: ${typeof userOptions.onEvent}`);
}
if (!serverBundle && onEvent) {
const originalOnEvent = onEvent;
const tempOnEvent = (event) => {
if (event.type === "build.writeBundle.server") {
serverBundle = event.data.bundle;
logger?.info(
"[react-static-client] Captured server bundle from build event"
);
}
originalOnEvent(event);
};
userOptions.onEvent = tempOnEvent;
}
const eventHandler = onEvent || userOptions.onEvent;
if (typeof eventHandler === "function") {
try {
if (userOptions.verbose) {
logger?.info(`[react-static-client] Emitting build.ssg.start event`);
}
const r = eventHandler({
type: "build.ssg.start",
data: {
pages: Array.from(autoDiscoveredFiles?.urlMap.keys() ?? []),
options: null,
// No specific rollup output options for static generation
bundle: staticBundle || {}
}
});
if (r != null && typeof r === "object" && "then" in r) {
await r;
}
} catch (error) {
const eventPanicError = handleError({
error,
logger,
panicThreshold: userOptions.panicThreshold,
context: "onEvent(build.ssg.start)"
});
if (eventPanicError != null) {
throw eventPanicError;
}
}
} else if (userOptions.verbose) {
logger?.warn(`[react-static-client] No onEvent handler available to emit build.ssg.start`);
}
const renderPagesGenerator = renderPagesBatched(
routes,
{
...handlerOptions,
// Use the clean options instead of the original handlerOptions
worker: rscWorker,
// Pass the RSC worker for RSC rendering only
rscWorker,
// Pass the RSC worker for RSC rendering only
loader: buildLoader,
// Use proper build loader instead of no-op
logger,
autoDiscoveredFiles,
cssFilesByPage,
// Pass CSS files by page
serverPipeableStreamOptions,
// Pass server options to RSC worker
clientPipeableStreamOptions,
// Pass client options to RSC worker
globalCss,
// Pass global CSS
manifest: serverManifest || {},
// Server manifest for RSC worker
staticManifest,
// Static manifest for consistent module IDs
onEvent,
onMetrics
// Pass through the onMetrics callback (metric watcher)
},
renderPage
);
let finalResult = void 0;
try {
for await (const result of renderPagesGenerator) {
if (result.type === "error") {
if (userOptions.verbose) {
logger?.error(`[react-static-client] Render error: ${result.error}`);
}
throw result.error;
}
if (result.type === "success" && result.failedRoutes && result.failedRoutes.size > 0) {
const firstError = result.failedRoutes.values().next().value;
if (firstError != null && shouldCausePanic(firstError, {
panicThreshold: userOptions.panicThreshold
})) {
throw firstError;
}
for (const [route, error] of result.failedRoutes) {
const err = error instanceof Error ? error : toError(error);
closeBundleContext.warn(
new Error(
"Failed to render route: " + route + "\n" + err.message + "\n" + err.stack,
{ cause: err }
)
);
}
}
finalResult = result;
}
} catch (renderError) {
if (userOptions.verbose) {
logger?.error(`[react-static-client] Error during renderPages: ${renderError}`);
}
throw renderError;
}
if (!finalResult) {
const errorMsg = "No render result produced";
if (userOptions.verbose) {
logger?.error(`[react-static-client] ${errorMsg}`);
}
throw new Error(errorMsg);
}
if (userOptions.verbose) {
logger?.info(`[react-static-client] Render completed: ${finalResult.completedRoutes.size} pages, ${finalResult.failedRoutes?.size || 0} failed`);
}
const duration = Math.round(
performance.now() - (timing.renderStart || timing.start)
);
closeBundleContext.info(
`Rendered ${finalResult.completedRoutes.size} pages in ${duration}ms`
);
if (process.env["NODE_ENV"] !== "production") {
closeBundleContext.warn(
`THIS BUILD IS NOT INTENDED FOR PRODUCTION (${process.env["NODE_ENV"]})`
);
}
timing.render = performance.now() - (timing.renderStart ?? timing.start);
if (userOptions.verbose) {
logger?.info("[react-static-client] Static generation completed");
}
if (typeof userOptions.onEvent === "function") {
try {
const r = userOptions.onEvent({
type: "build.ssg.end",
data: {
pages: Array.from(autoDiscoveredFiles?.urlMap.keys() ?? []),
options: null,
// No specific rollup output options for static generation
bundle: staticBundle || {}
}
});
if (r != null && typeof r === "object" && "then" in r) {
await r;
}
} catch (error) {
const eventPanicError = handleError({
error,
logger,
panicThreshold: userOptions.panicThreshold,
context: "onEvent(build.ssg.end)"
});
if (eventPanicError != null) {
throw eventPanicError;
}
}
}
} catch (error) {
const panicError = handleError({
error,
logger,
panicThreshold: userOptions.panicThreshold
});
if (rscWorker) {
const workerToCleanup = rscWorker;
try {
await Promise.race([
new Promise((resolve) => {
const timeoutId = setTimeout(() => {
workerToCleanup.removeAllListeners();
workerToCleanup.terminate();
resolve();
}, 1e3);
const messageHandler = (message) => {
if (message.type === "SHUTDOWN_COMPLETE") {
clearTimeout(timeoutId);
workerToCleanup.removeListener("message", messageHandler);
resolve();
}
};
workerToCleanup.on("message", messageHandler);
workerToCleanup.postMessage({ type: "SHUTDOWN" });
})
]);
rscWorker = void 0;
} catch (cleanupError) {
logger.warn(`Failed to cleanup worker on error: ${cleanupError}`);
try {
workerToCleanup.removeAllListeners();
workerToCleanup.terminate();
} catch (terminateError) {
}
rscWorker = void 0;
}
}
if (panicError != null) {
const errorToThrow = panicError instanceof Error ? panicError : new Error(String(panicError));
const finalError = new Error(errorToThrow.message);
finalError.stack = errorToThrow.stack;
finalError.cause = errorToThrow.cause;
if (errorToThrow.name) finalError.name = errorToThrow.name;
throw finalError;
}
} finally {
if (rscWorker) {
try {
await Promise.race([
new Promise((resolve, reject) => {
const timeout = setTimeout(() => {
reject(new Error("Worker shutdown timeout"));
}, userOptions.workerShutdownTimeout);
const backupTimeout = setTimeout(() => {
reject(new Error("Worker shutdown backup timeout"));
}, Math.floor(userOptions.workerShutdownTimeout * 0.6));
const shutdownMessageHandler = (message) => {
if (message.type === "SHUTDOWN_COMPLETE") {
clearTimeout(timeout);
clearTimeout(backupTimeout);
rscWorker?.removeListener(
"message",
shutdownMessageHandler
);
rscWorker?.removeAllListeners();
resolve();
}
};
rscWorker?.on("message", shutdownMessageHandler);
rscWorker?.postMessage({
type: "SHUTDOWN",
id: "*"
});
})
]);
} catch {
} finally {
if (rscWorker) {
try {
rscWorker.removeAllListeners();
await rscWorker.terminate();
} catch {
}
rscWorker = void 0;
}
}
}
autoDiscoveredFiles = null;
serverManifest = void 0;
}
});
}
};
};
export { reactStaticPlugin };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"plugin.client.js","sources":["../../../plugin/react-static/plugin.client.ts"],"sourcesContent":["/**\n * plugin.client.ts\n *\n * PURPOSE: Client-side static plugin for React Server Components\n *\n * This module:\n * 1. Handles static site generation in the client environment\n * 2. Uses RSC worker for RSC rendering and main-thread for HTML rendering\n * 3. Generates both RSC and HTML files for static pages\n * 4. Integrates with Vite's build process\n *\n * Feature parity with main react-static plugin, but in reverse. Uses rsc-worker to render rsc, and main thread for html.\n * This is not the default behavior, but is supported for testing and custom app development purposes.\n * Additionally, this can make it easier to use the --app flag to build all the modules + static generation at once.\n */\n\nimport {\n  createLogger,\n  type ResolvedConfig,\n  type Manifest,\n  type ConfigEnv,\n} from \"vite\";\nimport { resolveOptions } from \"../config/resolveOptions.js\";\nimport type {\n  BuildTiming,\n  VitePluginFn,\n  AutoDiscoveredFiles,\n} from \"../types.js\";\nimport type { OutputBundle } from \"rollup\";\nimport { renderPagesBatched } from \"./renderPagesBatched.js\";\nimport { performance } from \"node:perf_hooks\";\nimport { renderPage } from \"./renderPage.client.js\";\n\nimport { createWorker } from \"../worker/createWorker.js\";\nimport {\n  serializedOptions,\n  serializeResolvedConfig,\n} from \"../helpers/serializeUserOptions.js\";\nimport { getBundleManifest } from \"../helpers/getBundleManifest.js\";\n\nimport { handleError } from \"../error/handleError.js\";\nimport { shouldCausePanic } from \"../error/panicThresholdHandler.js\";\nimport { configurePreviewServer } from \"./configurePreviewServer.js\";\nimport { assertNonReactServer } from \"../config/getCondition.js\";\nimport { envPrefixFromConfig } from \"../config/envPrefixFromConfig.js\";\nimport { createWorkerStartupMetrics } from \"../metrics/createWorkerStartupMetrics.js\";\nimport { processCssFilesForPages } from \"./processCssFilesForPages.js\";\nimport { createBuildLoader } from \"./createBuildLoader.client.js\";\nimport { getNodeEnv } from \"../config/getNodeEnv.js\";\nimport { toError } from \"../error/toError.js\";\nimport {\n  addStaticManifest,\n  manifests,\n  getSharedManifestStore,\n} from \"../bundle/manifests.js\";\nimport { deferStaticGeneration } from \"../bundle/deferredStaticGeneration.js\";\nimport type { Worker } from \"node:worker_threads\";\nimport { resolveAutoDiscover } from \"../config/autoDiscover/resolveAutoDiscover.js\";\nimport { join } from \"node:path\";\n\nimport { baseURL } from \"../utils/envUrls.node.js\";\nimport { tryManifest } from \"../helpers/tryManifest.js\";\n// cssCollector removed - using filesystem-based CSS processing\n\nassertNonReactServer();\n\n/**\n * plugin.client.ts\n *\n * PURPOSE: Client-side static plugin for React Server Components\n *\n * This module:\n * 1. Handles static site generation in the client environment\n * 2. Uses RSC worker for RSC rendering and main-thread for HTML rendering\n * 3. Generates both RSC and HTML files for static pages\n * 4. Integrates with Vite's build process\n *\n * @param options\n * @returns\n */\nexport const reactStaticPlugin: VitePluginFn = function _reactStaticPlugin(\n  options\n) {\n  let logger: ReturnType<typeof createLogger>;\n  let autoDiscoveredFiles: AutoDiscoveredFiles | null = null;\n  let rscWorker: Worker | undefined = undefined;\n  let resolvedConfig: ResolvedConfig | null = null;\n  let serverManifest: Manifest | undefined = undefined;\n  let staticBundle: OutputBundle | undefined = undefined;\n  let serverBundle: OutputBundle | undefined = undefined;\n\n  let configEnv: ConfigEnv | undefined;\n  const timing: BuildTiming = {\n    start: performance.now(),\n    configResolved: 0,\n    buildStart: 0,\n    renderStart: 0,\n  };\n\n  const resolvedOptions = resolveOptions(options);\n  if (resolvedOptions.type === \"error\") {\n    throw resolvedOptions.error;\n  }\n  const userOptions = resolvedOptions.userOptions;\n\n  return {\n    name: \"vite:plugin-react-server/client-static\",\n    enforce: \"post\",\n    apply: \"build\", // Apply to build mode\n    api: {\n      meta: { timing },\n    },\n    async config(_config, viteConfigEnv) {\n      configEnv = viteConfigEnv;\n    },\n    applyToEnvironment(partialEnvironment) {\n      // Client static plugin should apply to static environment (browser/ESM builds)\n      // This is where we want to bundle everything and filter out _virtual files\n      // Apply to both \"static\" and \"client\" environments - we'll handle which one runs static generation in closeBundle\n      const envName = partialEnvironment.name as \"client\" | \"server\" | \"ssr\" | \"static\";\n      if (\n        [\"static\", \"client\"].includes(envName)\n      ) {\n        return true;\n      }\n      return false;\n    },\n\n    async configResolved(config) {\n      timing.configResolved = performance.now();\n      logger = config.customLogger || createLogger();\n      resolvedConfig = config;\n\n      // Perform auto-discovery to populate autoDiscoveredFiles\n      const autoDiscoverResult = await resolveAutoDiscover({\n        config: config,\n        configEnv: configEnv || {\n          mode: config.mode,\n          command: config.command,\n          isSsrBuild: false,\n          isPreview: false,\n        },\n        userOptions,\n        logger,\n      });\n      if (autoDiscoverResult.type === \"error\") {\n        throw autoDiscoverResult.error;\n      }\n      autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles;\n      if(userOptions.verbose) {\n        logger?.info(`Auto-discovery ${autoDiscoverResult.type === \"success\" ? \"completed\" : \"skipped\"}`);\n      }\n    },\n\n    async buildStart() {\n      timing.buildStart = performance.now();\n      if(userOptions.verbose) {\n        logger?.info(\"[react-static-client] Build started\");\n      }\n\n      if (userOptions.onEvent && autoDiscoveredFiles) {\n        try {\n          userOptions.onEvent({\n            type: \"build.start\",\n            data: {\n              pages: Array.from(autoDiscoveredFiles.urlMap.keys()),\n              files: autoDiscoveredFiles,\n            },\n          });\n        } catch (error) {\n          const panicError = handleError({\n            error,\n            logger: logger,\n            panicThreshold: userOptions.panicThreshold,\n            context: \"buildStart\",\n          });\n          if (panicError != null) {\n            rscWorker?.terminate();\n          throw panicError;\n          }\n        }\n      }\n    },\n\n    async renderStart() {\n      timing.renderStart = performance.now();\n      if(userOptions.verbose) { \n        logger?.info(\"[react-static-client] Render started\");\n      }\n    },\n\n    // the preview server helps to view the generated static folder, but only when the static plugin is enabled\n    // if no build.pages, then the preview server will instead use default vite preview server\n    // it works the same under both conditions\n    async configurePreviewServer(server) {\n      logger = server.config.customLogger || server.config.logger;\n      configurePreviewServer({\n        server,\n        userOptions,\n      });\n    },\n\n\n\n    async writeBundle(_options, bundle) {\n\n      // Capture manifests from all environments\n      try {\n        if (!autoDiscoveredFiles?.urlMap) {\n          return;\n        }\n\n        const bundleManifest = getBundleManifest<false>({\n          bundle,\n          normalizer: userOptions.normalizer,\n        });\n\n        // Store manifest based on environment\n        if (this.environment.name === \"static\") {\n          // Store in global manifest store for environment plugin access\n          addStaticManifest(bundleManifest);\n\n          staticBundle = bundle;\n        } else if (this.environment.name === \"client\") {\n          // Client build manifest (SSR modules) - stored globally now\n\n          if (manifests.static) {\n            const staticManifest = manifests.static;\n\n            // Update bundle filenames to match static manifest\n            for (const [, chunk] of Object.entries(bundle)) {\n              if (chunk.type === \"chunk\" && chunk.fileName) {\n                const normalized = userOptions.normalizer(chunk.fileName);\n                let value = normalized[1];\n                if (value.startsWith(userOptions.moduleBasePath)) {\n                  value = value.slice(userOptions.moduleBasePath.length);\n                }\n\n                const entry = staticManifest[value];\n                if (entry && entry.file !== chunk.fileName) {\n                  // Update the filename to match static manifest\n                  chunk.fileName = entry.file;\n                }\n              }\n            }\n          }\n        } else if (this.environment.name === \"server\") {\n          // Server build manifest (server components) - stored globally now\n          serverBundle = bundle;\n        }\n\n        // Skip the static generation here - it will happen in closeBundle\n        return;\n      } catch (error) {\n        const panicError = handleError({\n          error,\n          logger: logger,\n          panicThreshold: userOptions.panicThreshold,\n          context: \"writeBundle\",\n        });\n        if (panicError != null) {\n          throw panicError;\n        }\n      }\n    },\n\n    async closeBundle() {\n      const envName = this.environment.name;\n      const isSsr = this.environment.config.build?.ssr === true;\n      \n      if (userOptions.verbose) {\n        logger?.info(`[react-static-client] closeBundle called for environment: ${envName}, ssr: ${isSsr}`);\n      }\n      \n      // Only run static generation in the non-SSR client environment (static builds)\n      // Skip SSR client builds and server builds\n      if (envName === \"ssr\" || envName === \"server\" || isSsr) {\n        if (userOptions.verbose) {\n          logger?.info(`[react-static-client] Skipping static generation for environment: ${envName} (ssr: ${isSsr})`);\n        }\n        return;\n      }\n\n      // Clean up _virtual files after build completes\n      // These are Vite's internal virtual modules and aren't needed in the final output\n      if (envName === \"static\" || (envName === \"client\" && !isSsr)) {\n        try {\n          const { rmSync, existsSync } = await import(\"node:fs\");\n          const { join, resolve } = await import(\"node:path\");\n          \n          // Use the resolved output directory from the environment config\n          const resolvedOutDir = this.environment.config.build?.outDir \n            ? resolve(this.environment.config.root || userOptions.projectRoot, this.environment.config.build.outDir)\n            : resolve(userOptions.projectRoot, userOptions.build.outDir);\n          \n          // Clean up _virtual from client/static output directories only\n          // Don't clean up server/_virtual since we need dynamic-import-helper.js there\n          const outputDirs = [\n            join(resolvedOutDir, userOptions.build.static || \"static\"),\n            join(resolvedOutDir, userOptions.build.client || \"client\"),\n          ];\n          \n          for (const outDir of outputDirs) {\n            const virtualDir = join(outDir, \"_virtual\");\n            if (existsSync(virtualDir)) {\n              rmSync(virtualDir, { recursive: true, force: true });\n              if (userOptions.verbose) {\n                logger?.info(`[react-static-client] Cleaned up _virtual directory: ${virtualDir}`);\n              }\n            }\n          }\n        } catch (error) {\n          // Non-critical - log but don't fail the build\n          if (userOptions.verbose) {\n            logger?.warn(`[react-static-client] Failed to clean up _virtual directory: ${error}`);\n          }\n        }\n      }\n\n      // This runs after all writeBundle hooks are complete\n      // Run static generation in the non-SSR client environment (static builds)\n      // This could be \"static\" or \"client\" depending on how environments are configured\n      if (envName === \"ssr\" || envName === \"server\" || isSsr) {\n        if (userOptions.verbose) {\n          logger?.info(`[react-static-client] Skipping static generation - not in static environment (${envName}, ssr: ${isSsr})`);\n        }\n        return;\n      }\n\n      // Defer static generation to run after ALL environments complete their builds.\n      // This is necessary because we need the server manifest (from server env's writeBundle)\n      // to resolve function-based component paths like Root: (url) => 'src/CustomRoot.tsx'.\n      // The buildApp hook in createEnvironmentPlugin will call runDeferredStaticGeneration().\n      const closeBundleContext = this;\n      deferStaticGeneration(async () => {\n\n      try {\n        // Re-check autoDiscoveredFiles - it might not be set if configResolved didn't run\n        // or if it was cleared. Try to get it from stashed options if needed\n        if (!autoDiscoveredFiles) {\n          if (userOptions.verbose) {\n            logger?.warn(\"[react-static-client] autoDiscoveredFiles not set, attempting to re-discover\");\n          }\n          const { getStashedUserOptions, getEnvironmentId } = await import(\"../config/stashedOptionsState.js\");\n          const { getCondition } = await import(\"../config/getCondition.js\");\n          const envId = getEnvironmentId(getCondition(), resolvedConfig?.mode || \"production\");\n          const stashedOptions = getStashedUserOptions(envId);\n          if (stashedOptions && resolvedConfig) {\n            // Try to re-run auto-discovery if we have the config\n            const autoDiscoverResult = await resolveAutoDiscover({\n              config: resolvedConfig,\n              configEnv: configEnv || {\n                mode: resolvedConfig.mode || \"production\",\n                command: resolvedConfig.command || \"build\",\n                isSsrBuild: false,\n                isPreview: false,\n              },\n              userOptions,\n              logger,\n            });\n            if (autoDiscoverResult.type === \"success\") {\n              autoDiscoveredFiles = autoDiscoverResult.autoDiscoveredFiles;\n              if (userOptions.verbose) {\n                logger?.info(`[react-static-client] Re-discovered ${autoDiscoveredFiles.urlMap.size} pages`);\n              }\n            } else {\n              if (userOptions.verbose) {\n                logger?.warn(`[react-static-client] Failed to re-discover pages: ${autoDiscoverResult.error}`);\n              }\n            }\n          }\n        }\n\n        if (\n          !autoDiscoveredFiles?.urlMap ||\n          autoDiscoveredFiles?.urlMap.size === 0\n        ) {\n          if (userOptions.verbose) {\n            logger?.warn(`[react-static-client] No pages to generate - urlMap is empty (size: ${autoDiscoveredFiles?.urlMap?.size || 0})`);\n            logger?.warn(`[react-static-client] autoDiscoveredFiles exists: ${!!autoDiscoveredFiles}, urlMap exists: ${!!autoDiscoveredFiles?.urlMap}`);\n          }\n          return;\n        }\n\n        if (use