vinext 1.0.0-beta.12 → 1.0.0-beta.13

package/README.md

@@ -80,28 +80,39 @@ npm install react-server-dom-webpack
 npm install -D @vitejs/plugin-rsc
 ```
 
-Replace `next` with `vinext` in your scripts:
+Add a Vite config:
+
+```ts
+import { defineConfig } from "vite";
+import vinext from "vinext";
+
+export default defineConfig({
+  plugins: [vinext()],
+});
+```
+
+Then use Vite for development and builds:
 
 ```json
 {
   "scripts": {
-    "dev": "vinext dev",
-    "build": "vinext build",
+    "dev": "vite dev",
+    "build": "vite build",
     "start": "vinext start"
   }
 }
 ```
 
 ```bash
-vinext dev          # Development server with HMR
-vinext build        # Production build
+npx vite dev        # Development server with HMR
+npx vite build      # Production build
 npx @vinext/cloudflare deploy  # Build and deploy to Cloudflare Workers
 ```
 
 With Vite+, use `vpx @vinext/cloudflare deploy`, or
 `vp exec vinext-cloudflare deploy` when running the locally installed bin.
 
-vinext auto-detects your `app/` or `pages/` directory, loads `next.config.js`, and configures Vite automatically. No `vite.config.ts` required for basic usage.
+The `vinext()` plugin auto-detects your `app/` or `pages/` directory and loads `next.config.js`.
 
 Your existing `pages/`, `app/`, `next.config.js`, and `public/` directories work as-is. Run `vinext check` first to scan for known compatibility issues, or use `vinext init` to [automate the full migration](#migrating-an-existing-nextjs-project).
 
@@ -109,8 +120,8 @@ Your existing `pages/`, `app/`, `next.config.js`, and `public/` directories work
 
 | Command                            | Description                                                             |
 | ---------------------------------- | ----------------------------------------------------------------------- |
-| `vinext dev`                       | Start dev server with HMR                                               |
-| `vinext build`                     | Production build (multi-environment for App Router: RSC + SSR + client) |
+| `vite dev`                         | Start dev server with HMR                                               |
+| `vite build`                       | Production build (multi-environment for App Router: RSC + SSR + client) |
 | `vinext start`                     | Start local production server for testing                               |
 | `npx @vinext/cloudflare deploy`    | Build and deploy to Cloudflare Workers                                  |
 | `vp exec vinext-cloudflare deploy` | Build and deploy to Cloudflare Workers with Vite+                       |
@@ -118,7 +129,13 @@ Your existing `pages/`, `app/`, `next.config.js`, and `public/` directories work
 | `vinext check`                     | Scan your Next.js app for compatibility issues before migrating         |
 | `vinext lint`                      | Delegate to eslint or oxlint                                            |
 
-Options: `-p / --port <port>`, `-H / --hostname <host>`, `--turbopack` (accepted, no-op).
+`vinext dev` and `vinext build` remain as thin aliases for the project-local Vite commands.
+They require a Vite config; if one is missing, run `vinext init`. Vite owns their options,
+output, and exit behavior. For older configured projects, the aliases still preload dotenv
+before Vite evaluates the config and add `"type": "module"` (renaming known CommonJS config
+files to `.cjs`) when an unambiguous default Vite config requires the ESM migration. An explicit
+`"type": "commonjs"` is never changed. Direct `vite dev` and `vite build` do not perform these
+wrapper compatibility steps.
 
 `@vinext/cloudflare deploy` options: `--preview`, `--env <name>`, `--name <name>`, `--skip-build`, `--dry-run`, `--experimental-traffic-aware-warm-cache`.
 
@@ -127,7 +144,7 @@ user which target they want, then pass `--platform=cloudflare` or `--platform=no
 
 Other options: `--port <port>` (default: 3001), `--skip-check`, `--force`.
 
-If your `next.config.*` sets `output: "standalone"`, `vinext build` emits a self-hosting bundle at `dist/standalone/`. Start it with:
+If your `next.config.*` sets `output: "standalone"`, `vite build` emits a self-hosting bundle at `dist/standalone/`. Start it with:
 
 ```bash
 node dist/standalone/server.js
@@ -643,6 +660,15 @@ One caveat: modules whose JSX is lowered earlier in the pipeline are not memoize
 
 vinext automatically loads dotenv files for `dev`, `build`, `start`, and `deploy`.
 
+Vite evaluates all static config imports before plugin hooks, regardless of import order.
+`vinext dev` and `vinext build` preload dotenv from the project root before handing off to Vite,
+preserving the old CLI's config-time behavior. Direct `vite dev` and `vite build` do not. For
+config-time values that work with either command, use Vite's
+[`loadEnv(mode, process.cwd(), "")`](https://vite.dev/config/#using-environment-variables-in-config)
+in a config factory and read its returned values rather than relying on `process.env` in a static
+import. The empty prefix includes server-only variables; use your custom `envDir` in place of
+`process.cwd()` if you have one.
+
 Load order matches Next.js (highest priority first):
 
 1. Existing `process.env` values (shell/CI)
@@ -653,8 +679,9 @@ Load order matches Next.js (highest priority first):
 
 Modes:
 
-- `vinext dev` uses `development`
-- `vinext build`, `vinext start`, and `@vinext/cloudflare deploy` use `production`
+- `vite dev` uses `development`
+- `vite build`, `vinext start`, and `@vinext/cloudflare deploy` use `production`
+- `vinext dev` and `vinext build` use the corresponding mode, including `--mode` overrides
 
 Variable expansion (`$VAR` / `${VAR}`) is supported.
 

package/dist/build/action-owner-manifest.js

@@ -39,6 +39,17 @@ function actionOwnerRouteEntryIds(route) {
 		])
 	].filter((value) => typeof value === "string");
 }
+function memoizeModuleInfo(getModuleInfo) {
+	const cache = /* @__PURE__ */ new Map();
+	return (id) => {
+		let info = cache.get(id);
+		if (info === void 0) {
+			info = getModuleInfo(id);
+			cache.set(id, info);
+		}
+		return info;
+	};
+}
 function collectReachableActionReferences(options) {
 	const canonicalizeModuleId = options.canonicalizeModuleId ?? ((id) => id);
 	const clientReferenceImportIds = /* @__PURE__ */ new Set();
@@ -62,17 +73,18 @@ function collectReachableActionReferences(options) {
 	};
 }
 function collectRscActionReachability(options) {
+	const getModuleInfo = memoizeModuleInfo(options.getModuleInfo);
 	const routeReachability = new Map(options.routes.map((route) => [route.pattern, collectReachableActionReferences({
 		canonicalizeModuleId: options.canonicalizeModuleId,
 		clientReferenceMetaMap: options.clientReferenceMetaMap,
-		getModuleInfo: options.getModuleInfo,
+		getModuleInfo,
 		roots: actionOwnerRouteEntryIds(route),
 		serverReferenceMetaMap: options.serverReferenceMetaMap
 	})]));
 	if (options.sharedRoots?.length) routeReachability.set("*", collectReachableActionReferences({
 		canonicalizeModuleId: options.canonicalizeModuleId,
 		clientReferenceMetaMap: options.clientReferenceMetaMap,
-		getModuleInfo: options.getModuleInfo,
+		getModuleInfo,
 		roots: options.sharedRoots,
 		serverReferenceMetaMap: options.serverReferenceMetaMap
 	}));
@@ -80,21 +92,27 @@ function collectRscActionReachability(options) {
 }
 async function resolveClientReferenceImportIds(options) {
 	const canonicalizeModuleId = options.canonicalizeModuleId ?? ((id) => id);
+	const resolvedIdsByImportId = /* @__PURE__ */ new Map();
 	for (const reachability of options.routeReachability.values()) {
 		const resolvedImportIds = /* @__PURE__ */ new Set();
 		for (const importId of reachability.clientReferenceImportIds) {
-			const resolvedId = await options.resolveId(importId) ?? importId;
-			resolvedImportIds.add(canonicalizeModuleId(resolvedId));
+			let resolvedId = resolvedIdsByImportId.get(importId);
+			if (resolvedId === void 0) {
+				resolvedId = canonicalizeModuleId(await options.resolveId(importId) ?? importId);
+				resolvedIdsByImportId.set(importId, resolvedId);
+			}
+			resolvedImportIds.add(resolvedId);
 		}
 		reachability.clientReferenceImportIds = resolvedImportIds;
 	}
 }
 function addClientActionReachability(options) {
+	const getModuleInfo = memoizeModuleInfo(options.getModuleInfo);
 	for (const reachability of options.routeReachability.values()) {
 		const clientReachability = collectReachableActionReferences({
 			canonicalizeModuleId: options.canonicalizeModuleId,
 			clientReferenceMetaMap: options.clientReferenceMetaMap,
-			getModuleInfo: options.getModuleInfo,
+			getModuleInfo,
 			roots: [...reachability.clientReferenceImportIds],
 			serverReferenceMetaMap: options.serverReferenceMetaMap
 		});

package/dist/build/lifecycle.d.ts

@@ -0,0 +1,42 @@
+import { VinextCacheConfig } from "../cache/cache-adapters-virtual.js";
+import { ResolvedVinextPrerenderConfig, VinextRouteRootConfig } from "../config/prerender.js";
+import { ResolvedNextConfig } from "../config/next-config.js";
+import { runWithPreviewBuildCredentials } from "./preview-credentials.js";
+import { Plugin, PluginOption, ResolvedConfig, UserConfig, ViteBuilder } from "vite";
+//#region src/build/lifecycle.d.ts
+export type BuildLifecycleContext = {
+  cacheConfig: VinextCacheConfig | null;
+  configNodeEnv?: string;
+  createPagesOnlyPlugins: (pagesClientAssetsModule: string | null) => PluginOption[];
+  emptyOutDir?: boolean;
+  hasAppDir: boolean;
+  hasPagesDir: boolean;
+  nextConfig: ResolvedNextConfig;
+  prerenderAll?: boolean;
+  prerenderConfig: ResolvedVinextPrerenderConfig | null;
+  prerenderConcurrency?: number;
+  prerenderSecret: string;
+  previewBuildCredentials?: Parameters<typeof runWithPreviewBuildCredentials>[1];
+  revalidateSecret: string;
+  root: string;
+  routeRootConfig: VinextRouteRootConfig | null;
+  rscBuildIdentity?: string;
+  rscCompatibilityId?: string;
+  deferPostBuild?: boolean;
+  skipHybridPagesBundle?: boolean;
+};
+export declare const VINEXT_BUILD_LIFECYCLE_CONFIG = "__vinextBuildLifecycle";
+export type BuildLifecycleInvocation = {
+  onComplete?: () => void;
+};
+export declare function prepareBuildOutput(context: BuildLifecycleContext, emptyOutDir?: boolean | undefined): void;
+export declare function createBuildLifecyclePlugins(options: {
+  createContext: () => BuildLifecycleContext;
+  isEnabled: (builder: ViteBuilder) => boolean;
+  onComplete?: () => void;
+  onPrepare?: () => void;
+  shouldDeferPostBuild?: () => boolean;
+  shouldPrepare: (config: UserConfig | ResolvedConfig) => boolean;
+  shouldBuildPlainPages: () => boolean;
+}): Plugin[];
+//#endregion

package/dist/build/lifecycle.js

@@ -0,0 +1,246 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { flattenPluginOptions } from "../utils/plugin-options.js";
+import { hasBuildIdentityResponseHeader, hasUncachedRequestRouting, hasVerbatimResponseVary, isConfiguredCdnResponsePolicyHeader } from "../cache/cache-adapters-virtual.js";
+import { formatVinextPrerenderLabel, resolveVinextPrerenderDecision } from "../config/prerender.js";
+import { resolveVinextPackageRoot } from "../utils/vinext-root.js";
+import { cleanBuildOutput } from "./clean-output.js";
+import { PAGES_CLIENT_ASSETS_MODULE } from "./pages-client-assets-module.js";
+import { runWithPreviewBuildCredentials } from "./preview-credentials.js";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import { pathToFileURL } from "node:url";
+//#region src/build/lifecycle.ts
+const VINEXT_BUILD_LIFECYCLE_CONFIG = "__vinextBuildLifecycle";
+async function loadProjectViteApi(root) {
+	let vitePath;
+	try {
+		vitePath = createRequire(path.join(root, "package.json")).resolve("vite");
+	} catch {
+		vitePath = "vite";
+	}
+	return await (vitePath === "vite" ? import(vitePath) : import(pathToFileURL(vitePath).href));
+}
+function restoreEnvironment(previous) {
+	for (const [key, value] of previous) if (value === void 0) delete process.env[key];
+	else process.env[key] = value;
+}
+async function withEnvironment(values, callback) {
+	const previous = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(values)) {
+		previous.set(key, process.env[key]);
+		if (value === void 0) delete process.env[key];
+		else process.env[key] = value;
+	}
+	try {
+		return await callback();
+	} finally {
+		restoreEnvironment(previous);
+	}
+}
+function isInternalBuildPlugin(plugin) {
+	return plugin.name.startsWith("vinext:") || plugin.name.startsWith("vite:react") || plugin.name === "rsc" || plugin.name.startsWith("rsc:") || plugin.name === "vite-rsc-load-module-dev-proxy" || plugin.name.startsWith("vite-plugin-cloudflare");
+}
+async function loadHybridUserConfig(root, mode, configFile, configNodeEnv) {
+	if (!configFile) return {};
+	const vite = await loadProjectViteApi(root);
+	const load = () => vite.loadConfigFromFile({
+		command: "build",
+		mode,
+		isSsrBuild: true
+	}, configFile, root);
+	const loaded = configNodeEnv ? await withEnvironment({ NODE_ENV: configNodeEnv }, load) : await load();
+	if (!loaded) return {};
+	const plugins = await flattenPluginOptions(loaded.config.plugins);
+	return {
+		...loaded.config,
+		plugins: plugins.filter((plugin) => Boolean(plugin) && typeof plugin.name === "string" && !isInternalBuildPlugin(plugin)).map((plugin) => ({
+			...plugin,
+			buildApp: void 0
+		}))
+	};
+}
+async function buildHybridPagesBundle(builder, context) {
+	const vite = await loadProjectViteApi(context.root);
+	const userConfig = await loadHybridUserConfig(context.root, builder.config.mode, builder.config.configFile, context.configNodeEnv);
+	if (builder.config.logLevel !== "silent") console.log("  Building Pages Router server (hybrid)...");
+	const userSsrEnvironment = userConfig.environments?.ssr;
+	const { build: _userSsrBuild, ...pagesEnvironment } = userSsrEnvironment ?? {};
+	const mergedBuild = vite.mergeConfig(userConfig.build ?? {}, userSsrEnvironment?.build ?? {});
+	const userOutput = mergedBuild.rolldownOptions?.output;
+	const appAssetsPath = path.resolve(context.root, builder.environments.rsc?.config.build.outDir ?? "dist/server", PAGES_CLIENT_ASSETS_MODULE);
+	const pagesClientAssetsModule = fs.existsSync(appAssetsPath) ? fs.readFileSync(appAssetsPath, "utf8") : null;
+	const pagesBuild = {
+		...mergedBuild,
+		outDir: "dist/server",
+		emptyOutDir: false,
+		manifest: false,
+		ssr: "virtual:vinext-server-entry",
+		rolldownOptions: {
+			...mergedBuild.rolldownOptions,
+			output: Array.isArray(userOutput) ? userOutput.map((output) => ({
+				...output,
+				entryFileNames: "entry.js"
+			})) : {
+				...userOutput,
+				entryFileNames: "entry.js"
+			}
+		}
+	};
+	const pagesConfig = {
+		...userConfig,
+		root: context.root,
+		mode: builder.config.mode,
+		configFile: false,
+		plugins: [...userConfig.plugins ?? [], ...context.createPagesOnlyPlugins(pagesClientAssetsModule)],
+		builder: {
+			...userConfig.builder,
+			buildApp: async (pagesBuilder) => {
+				await pagesBuilder.build(pagesBuilder.environments.ssr);
+			}
+		},
+		environments: { ssr: {
+			...pagesEnvironment,
+			consumer: "server"
+		} },
+		resolve: {
+			...userConfig.resolve,
+			dedupe: [
+				...userConfig.resolve?.dedupe ?? [],
+				"react",
+				"react-dom",
+				"react/jsx-runtime",
+				"react/jsx-dev-runtime"
+			]
+		},
+		customLogger: builder.config.logger,
+		build: pagesBuild
+	};
+	const createPagesBuilder = () => vite.createBuilder(pagesConfig);
+	await (context.configNodeEnv ? await withEnvironment({ NODE_ENV: context.configNodeEnv }, createPagesBuilder) : await createPagesBuilder()).buildApp();
+}
+function checkStandaloneBuildPrerequisite(context) {
+	if (!context.deferPostBuild && context.nextConfig.output === "standalone") {
+		const vinextDistDir = path.join(resolveVinextPackageRoot(), "dist");
+		if (!fs.existsSync(vinextDistDir)) throw new Error(`vinext dist/ not found at ${vinextDistDir}. Build the vinext package before creating standalone output.`);
+	}
+}
+function prepareBuildOutput(context, emptyOutDir = context.emptyOutDir) {
+	checkStandaloneBuildPrerequisite(context);
+	cleanBuildOutput({
+		root: context.root,
+		outDir: path.resolve(context.root, "dist"),
+		emptyOutDir
+	});
+}
+async function finalizeBuild(builder, context) {
+	if (context.hasAppDir && context.hasPagesDir && !context.skipHybridPagesBundle) await withEnvironment({
+		__VINEXT_SHARED_BUILD_ID: context.nextConfig.buildId,
+		__VINEXT_SHARED_PRERENDER_SECRET: context.prerenderSecret,
+		__VINEXT_SHARED_REVALIDATE_SECRET: context.revalidateSecret,
+		__VINEXT_SHARED_RSC_BUILD_IDENTITY: context.rscBuildIdentity,
+		__VINEXT_SHARED_RSC_COMPATIBILITY_ID: context.rscCompatibilityId
+	}, () => runWithPreviewBuildCredentials(() => buildHybridPagesBundle(builder, context), context.previewBuildCredentials));
+	if (context.deferPostBuild) return;
+	if (context.nextConfig.output === "standalone") {
+		const { emitStandaloneOutput } = await import("./standalone.js");
+		const standalone = emitStandaloneOutput({
+			root: context.root,
+			outDir: path.resolve(context.root, "dist")
+		});
+		console.log(`  Generated standalone output in ${path.relative(context.root, standalone.standaloneDir)}/`);
+		console.log("  Start it with: node dist/standalone/server.js\n");
+		return;
+	}
+	const prerenderDecision = resolveVinextPrerenderDecision({
+		prerenderAllFlag: context.prerenderAll,
+		vinextPrerenderConfig: context.prerenderConfig,
+		nextOutput: context.nextConfig.output
+	});
+	let prerenderResult;
+	if (prerenderDecision) {
+		if (context.nextConfig.enablePrerenderSourceMaps) {
+			process.setSourceMapsEnabled(true);
+			Error.stackTraceLimit = Math.max(Error.stackTraceLimit, 50);
+		}
+		console.log(`  ${formatVinextPrerenderLabel(prerenderDecision)}`);
+		const [{ emitPrerenderPathManifest }, { runPrerender }] = await Promise.all([import("./prerender-paths.js"), import("./run-prerender.js")]);
+		prerenderResult = await runPrerender({
+			root: context.root,
+			concurrency: context.prerenderConcurrency,
+			nextConfig: context.nextConfig,
+			routeRootConfig: context.routeRootConfig
+		});
+		await emitPrerenderPathManifest({
+			root: context.root,
+			nextConfig: context.nextConfig,
+			buildIdentity: hasBuildIdentityResponseHeader(context.cacheConfig) ? "response-header" : void 0,
+			responseVary: hasVerbatimResponseVary(context.cacheConfig) ? "verbatim" : void 0,
+			requestRouting: hasUncachedRequestRouting(context.cacheConfig) ? "uncached-stage" : void 0,
+			isResponsePolicyHeader: (name) => isConfiguredCdnResponsePolicyHeader(context.cacheConfig, name),
+			routeRootConfig: context.routeRootConfig
+		});
+	}
+	const { printBuildReport } = await import("./report.js");
+	await printBuildReport({
+		root: context.root,
+		pageExtensions: context.nextConfig.pageExtensions,
+		prerenderResult: prerenderResult ?? void 0
+	});
+	console.log("\n  Build complete.\n");
+}
+function createBuildLifecyclePlugins(options) {
+	let outputPrepared = false;
+	const createContext = () => ({
+		...options.createContext(),
+		deferPostBuild: options.shouldDeferPostBuild?.()
+	});
+	const finalizePlugin = {
+		name: "vinext:build-lifecycle-finalize",
+		apply: "build",
+		enforce: "post",
+		configResolved: {
+			order: "post",
+			handler(config) {
+				const plugins = config.plugins;
+				const index = plugins.indexOf(finalizePlugin);
+				if (index !== -1 && index !== plugins.length - 1) plugins.push(...plugins.splice(index, 1));
+			}
+		},
+		buildApp: {
+			order: "post",
+			async handler(builder) {
+				if (!options.isEnabled(builder)) return;
+				await finalizeBuild(builder, createContext());
+				options.onComplete?.();
+			}
+		}
+	};
+	return [{
+		name: "vinext:build-lifecycle-prepare",
+		apply: "build",
+		configResolved: {
+			order: "pre",
+			handler(config) {
+				if (outputPrepared || !options.shouldPrepare(config)) return;
+				const context = createContext();
+				if (config.build.emptyOutDir === false) context.emptyOutDir = false;
+				checkStandaloneBuildPrerequisite(context);
+				options.onPrepare?.();
+				prepareBuildOutput(context);
+				outputPrepared = true;
+			}
+		},
+		buildApp: {
+			order: "pre",
+			async handler(builder) {
+				if (!options.isEnabled(builder) || !options.shouldBuildPlainPages()) return;
+				for (const name of ["client", "ssr"]) {
+					const environment = builder.environments[name];
+					if (environment && !environment.isBuilt) await builder.build(environment);
+				}
+			}
+		}
+	}, finalizePlugin];
+}
+//#endregion
+export { VINEXT_BUILD_LIFECYCLE_CONFIG, createBuildLifecyclePlugins, prepareBuildOutput };

package/dist/build/nitro-route-rules.js

@@ -1,6 +1,6 @@
+import { appRouter } from "../routing/app-router.js";
 import { apiRouter, pagesRouter } from "../routing/pages-router.js";
 import { buildReportRows } from "./report.js";
-import { appRouter } from "../routing/app-router.js";
 //#region src/build/nitro-route-rules.ts
 /**
 * Scans the filesystem for route files and generates Nitro `routeRules` for ISR routes.

package/dist/build/pages-client-assets-module.d.ts

@@ -3,7 +3,4 @@ import { PagesClientAssets } from "../server/pages-client-assets.js";
 export declare const PAGES_CLIENT_ASSETS_MODULE = "vinext-client-assets.js";
 export declare function buildPagesClientAssetsModule(assets: PagesClientAssets): string;
 export declare function writePagesClientAssetsModuleIfMissing(outputDir: string, moduleSource: string): void;
-export declare function setPagesClientAssetsBuildMetadata(buildSession: string, moduleSource: string): void;
-export declare function takePagesClientAssetsBuildMetadata(buildSession: string): string | null;
-export declare function clearPagesClientAssetsBuildMetadata(buildSession: string): void;
 //#endregion

package/dist/build/pages-client-assets-module.js

@@ -2,7 +2,6 @@ import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import fs from "node:fs";
 //#region src/build/pages-client-assets-module.ts
 const PAGES_CLIENT_ASSETS_MODULE = "vinext-client-assets.js";
-const pagesClientAssetsByBuildSession = /* @__PURE__ */ new Map();
 function buildPagesClientAssetsModule(assets) {
 	return `export default ${JSON.stringify(assets)};\n`;
 }
@@ -12,16 +11,5 @@ function writePagesClientAssetsModuleIfMissing(outputDir, moduleSource) {
 	fs.mkdirSync(outputDir, { recursive: true });
 	fs.writeFileSync(outputPath, moduleSource);
 }
-function setPagesClientAssetsBuildMetadata(buildSession, moduleSource) {
-	pagesClientAssetsByBuildSession.set(buildSession, moduleSource);
-}
-function takePagesClientAssetsBuildMetadata(buildSession) {
-	const moduleSource = pagesClientAssetsByBuildSession.get(buildSession) ?? null;
-	pagesClientAssetsByBuildSession.delete(buildSession);
-	return moduleSource;
-}
-function clearPagesClientAssetsBuildMetadata(buildSession) {
-	pagesClientAssetsByBuildSession.delete(buildSession);
-}
 //#endregion
-export { PAGES_CLIENT_ASSETS_MODULE, buildPagesClientAssetsModule, clearPagesClientAssetsBuildMetadata, setPagesClientAssetsBuildMetadata, takePagesClientAssetsBuildMetadata, writePagesClientAssetsModuleIfMissing };
+export { PAGES_CLIENT_ASSETS_MODULE, buildPagesClientAssetsModule, writePagesClientAssetsModuleIfMissing };

package/dist/build/precompress.js

@@ -1,9 +1,9 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { ASSET_PREFIX_URL_DIR } from "../utils/asset-prefix.js";
 import { isPrecompressedVariantBeneficial } from "../utils/precompressed-variant.js";
-import fsp from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import { promisify } from "node:util";
+import fsp from "node:fs/promises";
 import os from "node:os";
 import zlib from "node:zlib";
 //#region src/build/precompress.ts

package/dist/build/prerender-paths.d.ts

@@ -1,6 +1,6 @@
-import { ResolvedNextConfig } from "../config/next-config.js";
 import { CdnCacheAdapterCapabilities } from "../cache/cache-adapters-virtual.js";
 import { VinextRouteRootConfig } from "../config/prerender.js";
+import { ResolvedNextConfig } from "../config/next-config.js";
 import { MatcherConfig } from "../server/middleware-matcher.js";
 //#region src/build/prerender-paths.d.ts
 export type PrerenderRoutePattern = {

package/dist/build/prerender-paths.js

@@ -1,26 +1,26 @@
 import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { findDir } from "../utils/project.js";
-import { apiRouter, matchRoute, pagesRouter } from "../routing/pages-router.js";
+import { BLOCKED_PAGES, PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
 import { VINEXT_PRERENDER_SECRET_HEADER } from "../utils/protocol-headers.js";
-import "../server/headers.js";
 import { isExternalUrl } from "../utils/external-url.js";
 import { matchHeaders, matchesRewriteSource } from "../config/config-matchers.js";
+import { loadNextConfig, resolveNextConfig } from "../config/next-config.js";
+import { appRouteHasMainTreeLoadingBoundary, appRouter, matchAppRoute } from "../routing/app-router.js";
+import { apiRouter, matchRoute, pagesRouter } from "../routing/pages-router.js";
+import "../server/headers.js";
 import { matchesMiddlewarePathname } from "../server/middleware-matcher.js";
 import { extractLocaleFromUrl, normalizeDefaultLocalePathname } from "../server/pages-i18n.js";
 import { classifyAppRoute, classifyAppRouteHandler, classifyPagesRoute, extractExportConstString, extractMiddlewareMatcherConfig, getAppRouteRenderEntryPath } from "./report.js";
-import { appRouteHasMainTreeLoadingBoundary, appRouter, matchAppRoute } from "../routing/app-router.js";
 import { normalizeStaticPathname, normalizeStaticPathsEntry } from "../routing/route-pattern.js";
 import { buildPagesDataHref } from "../shims/internal/pages-data-url.js";
 import { normalizePathTrailingSlash } from "../shims/url-utils.js";
-import { BLOCKED_PAGES, PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
-import { loadNextConfig, resolveNextConfig } from "../config/next-config.js";
 import { pagesRouteHasPriorityOverAppRoute } from "../server/hybrid-route-priority.js";
 import { readPrerenderSecret } from "./server-manifest.js";
 import { startProdServer } from "../server/prod-server.js";
 import { enterPrerenderPhase } from "./prerender-phase.js";
 import { buildUrlFromParams, resolveParentParams } from "./prerender.js";
-import { resolveBuiltRscEntryPath } from "./server-entry.js";
 import { resolveAppPageDynamicConfig } from "../server/app-segment-config.js";
+import { resolveBuiltRscEntryPath } from "./server-entry.js";
 import fs from "node:fs";
 //#region src/build/prerender-paths.ts
 const PRERENDER_PATH_DISCOVERY_ENV = "__VINEXT_PRERENDER_PATH_DISCOVERY";

package/dist/build/prerender-server-pool.js

@@ -2,8 +2,8 @@ import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
 import fs from "node:fs";
 import { fileURLToPath } from "node:url";
-import os from "node:os";
 import { fork } from "node:child_process";
+import os from "node:os";
 //#region src/build/prerender-server-pool.ts
 /**
 * Parallel prerender server pool.

package/dist/build/prerender.d.ts

@@ -218,7 +218,7 @@ export declare function prerenderPages({ routes, apiRoutes, pagesDir, outDir, co
  * `vinext-prerender.json` to `outDir`.
  *
  * If the bundle does not exist, an error is thrown directing the user to run
- * `vinext build` first.
+ * `vite build` first.
  *
  * Speculative static rendering: routes classified as 'unknown' (no explicit
  * config, non-dynamic URL) are attempted with an empty headers/cookies context.

package/dist/build/prerender.js

@@ -1,4 +1,5 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { BLOCKED_PAGES } from "../shims/constants.js";
 import { createValidFileMatcher, findFileWithExtensions } from "../routing/file-matcher.js";
 import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER } from "../utils/protocol-headers.js";
 import { NEXT_CACHE_TAGS_HEADER, VINEXT_METADATA_ROUTE_CACHE_HEADER, VINEXT_PRERENDER_CACHE_LIFE_HEADER, VINEXT_PRERENDER_METADATA_ROUTES_PATH, VINEXT_PRERENDER_RENDER_ERROR_HEADER } from "../server/headers.js";
@@ -8,7 +9,6 @@ import { NoOpCacheHandler, getCacheHandler, setCacheHandler } from "../shims/cac
 import { headersContextFromRequest, runWithHeadersContext } from "../shims/headers.js";
 import { _consumeRequestScopedCacheLife } from "../shims/cache-request-state.js";
 import { normalizeStaticPathsEntry } from "../routing/route-pattern.js";
-import { BLOCKED_PAGES } from "../shims/constants.js";
 import { readPrerenderSecret } from "./server-manifest.js";
 import { buildPregeneratedConcretePathTable } from "../server/prerender-manifest.js";
 import { concatUint8Arrays, decodeRscEmbeddedChunk } from "../server/app-rsc-embedded-chunks.js";
@@ -25,7 +25,7 @@ import fs from "node:fs";
 import os from "node:os";
 //#region src/build/prerender.ts
 /**
-* Prerendering phase for vinext build.
+* Prerendering phase for vite build.
 *
 * Classifies every route, renders static and ISR routes to HTML/JSON/RSC files,
 * and writes a `vinext-prerender.json` build index.
@@ -290,7 +290,7 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 	try {
 		let prerenderSecret = options._prerenderSecret;
 		if (!prerenderSecret && pagesBundlePath) prerenderSecret = readPrerenderSecret(path.dirname(pagesBundlePath));
-		if (!prerenderSecret) console.warn("[vinext] Warning: prerender secret not found. /__vinext/prerender/* endpoints will return 403 and dynamic routes will produce no paths. Run `vinext build` to regenerate the secret.");
+		if (!prerenderSecret) console.warn("[vinext] Warning: prerender secret not found. /__vinext/prerender/* endpoints will return 403 and dynamic routes will produce no paths. Run `vite build` to regenerate the secret.");
 		const prodServer = options._prodServer ? options._prodServer : await (async () => {
 			const srv = await startProdServer({
 				port: 0,
@@ -534,7 +534,7 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 * `vinext-prerender.json` to `outDir`.
 *
 * If the bundle does not exist, an error is thrown directing the user to run
-* `vinext build` first.
+* `vite build` first.
 *
 * Speculative static rendering: routes classified as 'unknown' (no explicit
 * config, non-dynamic URL) are attempted with an empty headers/cookies context.
@@ -559,7 +559,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 	let renderRoundRobin = 0;
 	try {
 		const prerenderSecret = readPrerenderSecret(serverDir);
-		if (!prerenderSecret) console.warn("[vinext] Warning: prerender secret not found. /__vinext/prerender/* endpoints will return 403 and generateStaticParams will not be called. Run `vinext build` to regenerate the secret.");
+		if (!prerenderSecret) console.warn("[vinext] Warning: prerender secret not found. /__vinext/prerender/* endpoints will return 403 and generateStaticParams will not be called. Run `vite build` to regenerate the secret.");
 		const prodServer = options._prodServer ? options._prodServer : await (async () => {
 			const srv = await startProdServer({
 				port: 0,

package/dist/build/preview-credentials.d.ts

@@ -6,5 +6,5 @@ export type PreviewBuildCredentials = {
 };
 export declare function createPreviewBuildCredentials(): PreviewBuildCredentials;
 export declare function getPreviewBuildCredentials(): PreviewBuildCredentials | undefined;
-export declare function runWithPreviewBuildCredentials<T>(callback: () => T): T;
+export declare function runWithPreviewBuildCredentials<T>(callback: () => T, credentials?: PreviewBuildCredentials): T;
 //#endregion

package/dist/build/preview-credentials.js

@@ -12,8 +12,8 @@ function createPreviewBuildCredentials() {
 function getPreviewBuildCredentials() {
 	return previewBuildCredentialsStorage.getStore();
 }
-function runWithPreviewBuildCredentials(callback) {
-	return previewBuildCredentialsStorage.run(createPreviewBuildCredentials(), callback);
+function runWithPreviewBuildCredentials(callback, credentials = createPreviewBuildCredentials()) {
+	return previewBuildCredentialsStorage.run(credentials, callback);
 }
 //#endregion
 export { createPreviewBuildCredentials, getPreviewBuildCredentials, runWithPreviewBuildCredentials };