vinext 1.0.0 → 1.1.0

package/dist/init-cloudflare.js

@@ -26,7 +26,6 @@ const CACHE_METADATA_EXPORT = {
 };
 const CTX_EXPORTS_DEFAULT_DATE = "2025-11-17";
 function validateCloudflarePlatformSetup(context, cloudflare) {
-	if (cloudflare.cdnCache === "static-assets" && !context.isAppRouter) throw new Error("The Static Assets cache currently requires an App Router project.");
 	if (!cloudflare.legacyWrangler) {
 		const existingWrangler = [
 			"wrangler.toml",
@@ -107,7 +106,7 @@ function setupCloudflarePlatform(context, cloudflare) {
 			generatedViteConfig = true;
 		} else skippedViteConfig = true;
 	} else {
-		const configContent = context.isAppRouter ? generateAppRouterViteConfig(projectInfo, cloudflare, imagesBinding, versionMetadataBinding, false, assetsBinding, assetsDirectory, context.hasCssModules) : generatePagesRouterViteConfig(projectInfo, cloudflare, imagesBinding, versionMetadataBinding, false, context.hasCssModules);
+		const configContent = context.isAppRouter ? generateAppRouterViteConfig(projectInfo, cloudflare, imagesBinding, versionMetadataBinding, false, assetsBinding, assetsDirectory, context.hasCssModules) : generatePagesRouterViteConfig(projectInfo, cloudflare, imagesBinding, versionMetadataBinding, false, context.hasCssModules, assetsBinding, assetsDirectory);
 		fs.writeFileSync(path.join(context.root, "vite.config.ts"), configContent, "utf-8");
 		generatedViteConfig = true;
 	}
@@ -799,7 +798,8 @@ ${plugins.join("\n")}
 `;
 }
 /** Generate vite.config.ts for Pages Router */
-function generatePagesRouterViteConfig(info, options = DEFAULT_CLOUDFLARE_INIT_OPTIONS, imagesBinding = "IMAGES", versionMetadataBinding = DEFAULT_VERSION_METADATA_BINDING, serviceBinding = false, hasCssModules = false) {
+function generatePagesRouterViteConfig(info, options = DEFAULT_CLOUDFLARE_INIT_OPTIONS, imagesBinding = "IMAGES", versionMetadataBinding = DEFAULT_VERSION_METADATA_BINDING, serviceBinding = false, hasCssModules = false, assetsBinding = "ASSETS", assetsDirectory = "dist/client") {
+	const legacyStaticAssets = options.legacyWrangler && options.cdnCache === "static-assets";
 	const imports = [
 		`import { defineConfig } from "vite";`,
 		`import vinext from "vinext";`,
@@ -816,9 +816,9 @@ function generatePagesRouterViteConfig(info, options = DEFAULT_CLOUDFLARE_INIT_O
 	return `${imports.join("\n")}
 
 export default defineConfig({
-  plugins: [
-${hasCssModules ? "    patchCssModules({ exportMode: \"default\" }),\n" : ""}    ${vinextExpression(options, "vinext", "imagesOptimizer", imagesBinding, versionMetadataBinding).replace(/\n/g, "\n    ")},
-    cloudflare(${serviceBinding ? "{ auxiliaryWorkers: [{ config: responseStoreServiceBinding }] }" : ""}),
+${legacyStaticAssets ? `  environments: { client: { build: { outDir: ${JSON.stringify(assetsDirectory)} } }, ssr: { build: { outDir: "dist/server" } } },\n` : ""}  plugins: [
+${hasCssModules ? "    patchCssModules({ exportMode: \"default\" }),\n" : ""}    ${vinextExpression(options, "vinext", "imagesOptimizer", imagesBinding, versionMetadataBinding, "responseStoreAdapter", assetsBinding, assetsDirectory).replace(/\n/g, "\n    ")},
+    cloudflare(${legacyStaticAssets ? "{ viteEnvironment: { name: \"ssr\" } }" : serviceBinding ? "{ auxiliaryWorkers: [{ config: responseStoreServiceBinding }] }" : ""}),
   ],${resolveBlock}${hasCssModules ? cssModulesConfigSource() : ""}
 });
 `;

package/dist/init-platform.js

@@ -269,7 +269,7 @@ async function resolveCloudflareInitOptions(args, options = {}) {
 			}
 			output.write("  Please answer yes or no.\n");
 		}
-		const cdnCache = await promptChoice(selectedCdnCache, "  Choose a CDN cache:\n    1. Workers Response Store (default)\n    2. Workers Cache\n    3. Data cache\n    4. Static Assets (read-only; App Router only)\n  CDN cache [1]: ", {
+		const cdnCache = await promptChoice(selectedCdnCache, "  Choose a CDN cache:\n    1. Workers Response Store (default)\n    2. Workers Cache\n    3. Data cache\n    4. Static Assets (read-only)\n  CDN cache [1]: ", {
 			"1": "response-store",
 			"response-store": "response-store",
 			"2": "workers-cache",

package/dist/init.js

@@ -412,8 +412,9 @@ async function init(options) {
 		existingViteConfigPath = renamedPath;
 	}
 	const addedTypeModule = ensureESModule(root);
+	const deployResponseStore = platform === "cloudflare" && options.cloudflare?.cdnCache === "response-store" && (options.cloudflare.responseStoreMode ?? "service-binding") === "service-binding";
 	const addedScripts = addScripts(root, options.port, platform, {
-		deployResponseStore: options.cloudflare?.cdnCache === "response-store" && (options.cloudflare.responseStoreMode ?? "service-binding") === "service-binding",
+		deployResponseStore,
 		warmCdnCache: options.cloudflare?.warmCdnCache ?? false,
 		legacyWrangler: options.cloudflare?.legacyWrangler,
 		scriptNames: options.scriptNames
@@ -516,6 +517,7 @@ async function init(options) {
 	const nextSteps = [...platformSetup.nextSteps];
 	if (dependencyInstallNeedsApproval) nextSteps.push("Dependency installation is incomplete because pnpm blocked dependency build scripts:", "1. Review and approve the required build scripts:", "   pnpm approve-builds", "2. Finish installing dependencies:", "   pnpm install");
 	const scriptName = (name) => options.scriptNames === "standard" ? name : `${name}:vinext`;
+	const deployResponseStoreCommandStep = deployResponseStore ? `    ${pmName} run deploy:response-store  Deploy Workers Response Store before the application\n` : "";
 	const deployCommandStep = platform === "cloudflare" ? `    ${pmName} run ${scriptName("deploy")} Deploy to Cloudflare Workers\n` : "";
 	const startCommandDescription = platform === "cloudflare" ? !options.cloudflare?.legacyWrangler ? "Preview the built Worker locally" : "Start the built Worker locally with Wrangler" : "Start vinext production server";
 	console.log(`
@@ -524,7 +526,7 @@ ${nextSteps.map((step) => `    ${step}`).join("\n")}${nextSteps.length > 0 ? "\n
     ${pmName} run ${scriptName("dev")}    Start the vinext dev server
     ${pmName} run ${scriptName("build")}  Build production output
     ${pmName} run ${scriptName("start")}  ${startCommandDescription}
-${deployCommandStep}${options.scriptNames === "standard" ? "" : `    ${pmName} run dev           Start Next.js (still works as before)\n`}
+${deployResponseStoreCommandStep}${deployCommandStep}${options.scriptNames === "standard" ? "" : `    ${pmName} run dev           Start Next.js (still works as before)\n`}
 `);
 	return {
 		installedDeps: [.../* @__PURE__ */ new Set([...dependencyEntriesAdded, ...devDependencyEntriesAdded])],

package/dist/plugins/cache-flight-codec.d.ts

@@ -0,0 +1,19 @@
+import { MagicStringTransformResult } from "./transform-result.js";
+import { Plugin } from "vite";
+//#region src/plugins/cache-flight-codec.d.ts
+/**
+ * Version of the Flight codec package that owns `id`. plugin-rsc resolves the
+ * app's own react-server-dom-webpack when installed and its vendored copy
+ * otherwise; reading the codec file's own package.json follows that choice.
+ */
+export declare function readFlightCodecVersion(id: string): string;
+/**
+ * Backport React 19.3's root-element temporary reference branch to older Flight
+ * codecs, so a "use cache" argument like `Promise<ReactElement>` encodes as a
+ * temporary reference instead of throwing. Remove it once React 19.3 is the
+ * minimum supported version.
+ * https://github.com/facebook/react/blob/v19.3.0/packages/react-client/src/ReactFlightReplyClient.js#L486
+ */
+export declare function patchCacheFlightCodec(code: string, id: string, version?: string): MagicStringTransformResult | null;
+export declare function cacheFlightCodecPlugin(): Plugin;
+//#endregion

package/dist/plugins/cache-flight-codec.js

@@ -0,0 +1,68 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { magicStringTransformResult } from "./transform-result.js";
+import fs from "node:fs";
+import MagicString from "magic-string";
+//#region src/plugins/cache-flight-codec.ts
+const CLIENT_CODEC = /\/react-server-dom-(?:webpack|turbopack)-client\.edge\.(?:development|production)\.js$/;
+const ELEMENT_CASE = /case REACT_ELEMENT_TYPE:[\s\S]*?throw Error\(\s*"React Element cannot be passed/;
+/**
+* Version of the Flight codec package that owns `id`. plugin-rsc resolves the
+* app's own react-server-dom-webpack when installed and its vendored copy
+* otherwise; reading the codec file's own package.json follows that choice.
+*/
+function readFlightCodecVersion(id) {
+	for (let dir = path.dirname(id);; dir = path.dirname(dir)) {
+		const manifest = path.join(dir, "package.json");
+		if (fs.existsSync(manifest)) {
+			const pkg = JSON.parse(fs.readFileSync(manifest, "utf8"));
+			if (/^react-server-dom-(?:webpack|turbopack)$/.test(pkg.name ?? "") && pkg.version) return pkg.version;
+		}
+		if (path.dirname(dir) === dir) throw new Error(`vinext: cannot find the react-server-dom package version for ${id}`);
+	}
+}
+/** React 19.3 ships the branch; 0.0.0-* experimental builds track main. */
+function needsElementTemporaryReferenceBackport(version) {
+	const match = /^(\d+)\.(\d+)\./.exec(version);
+	if (!match || version.startsWith("0.0.0-")) return false;
+	const [major, minor] = [Number(match[1]), Number(match[2])];
+	return major < 19 || major === 19 && minor < 3;
+}
+/**
+* Backport React 19.3's root-element temporary reference branch to older Flight
+* codecs, so a "use cache" argument like `Promise<ReactElement>` encodes as a
+* temporary reference instead of throwing. Remove it once React 19.3 is the
+* minimum supported version.
+* https://github.com/facebook/react/blob/v19.3.0/packages/react-client/src/ReactFlightReplyClient.js#L486
+*/
+function patchCacheFlightCodec(code, id, version = readFlightCodecVersion(id)) {
+	if (!needsElementTemporaryReferenceBackport(version)) return null;
+	const elementCase = ELEMENT_CASE.exec(code);
+	if (!elementCase) throw new Error(`vinext: react-server-dom-webpack ${version} (${id}) is not supported. Upgrade react, react-dom, and react-server-dom-webpack to 19.3 or later. If your app does not depend on react-server-dom-webpack directly, upgrade @vitejs/plugin-rsc to 0.5.35 or later instead.`);
+	const output = new MagicString(code);
+	output.appendLeft(elementCase.index + elementCase[0].lastIndexOf("throw Error("), "if (void 0 !== temporaryReferences && modelRoot === value) return (modelRoot = null), \"$T\";\n");
+	return magicStringTransformResult(output, {
+		hires: "boundary",
+		source: id
+	});
+}
+function cacheFlightCodecPlugin() {
+	const transform = {
+		filter: { id: CLIENT_CODEC },
+		handler: (code, id) => patchCacheFlightCodec(code, id)
+	};
+	return {
+		name: "vinext:cache-flight-codec",
+		enforce: "pre",
+		applyToEnvironment: (environment) => environment.name === "rsc",
+		configEnvironment(name) {
+			if (name !== "rsc") return;
+			return { optimizeDeps: { rolldownOptions: { plugins: [{
+				name: "vinext:cache-flight-codec-optimizer",
+				transform
+			}] } } };
+		},
+		transform
+	};
+}
+//#endregion
+export { cacheFlightCodecPlugin, patchCacheFlightCodec, readFlightCodecVersion };

package/dist/plugins/commonjs-esm-facade.d.ts

@@ -0,0 +1,35 @@
+import { Plugin } from "vite";
+//#region src/plugins/commonjs-esm-facade.d.ts
+/**
+ * Removes the export facade vite-plugin-commonjs appended to `output` when the
+ * module it transformed is ESM. Returns `undefined` when there is nothing to
+ * remove.
+ *
+ * Next.js treats a module with ESM syntax as ESM: `require()` still works, but
+ * `module` / `exports` never become its exports. The plugin's analyzer is not
+ * scope-aware, so for bundled ESM that inlines CommonJS wrappers
+ * (`__commonJS((exports, module) => …)`) it exports the wrappers' assignments
+ * too, which duplicates the module's own exports. Its `require()` rewrite and
+ * its local `module` / `exports` polyfill stay, so free CommonJS assignments
+ * still run without becoming exports.
+ *
+ * Besides the facade, the plugin only prepends imports and its polyfill and
+ * rewrites `require()` calls, so the module's own top-level exports are still
+ * in `output`. Classifying the output rather than rereading the source keeps
+ * the decision tied to the exact code the plugin transformed.
+ *
+ * The facade is appended after the module's code (only dynamic-require
+ * runtimes, which have no source mappings, may follow it), so removing it
+ * leaves the plugin's source map valid.
+ */
+export declare function stripEsmCommonJsExportFacade(output: string): string | undefined;
+/**
+ * Applies {@link stripEsmCommonJsExportFacade} in the client dependency
+ * optimizer's Rolldown builds (scan and pre-bundle). vite-plugin-commonjs's
+ * pre-bundle plugin loads and converts files there without vinext's transform
+ * wrapper, so its output reaches this hook as the loaded code. That code is
+ * the optimizer's source, so the removal needs its own map for anything the
+ * plugin appended after the facade.
+ */
+export declare const commonJsEsmFacadeOptimizeDepsPlugin: Plugin;
+//#endregion

package/dist/plugins/commonjs-esm-facade.js

@@ -0,0 +1,80 @@
+import { parseAst } from "vite";
+import MagicString from "magic-string";
+//#region src/plugins/commonjs-esm-facade.ts
+const EXPORT_FACADE_START = "/* [vite-plugin-commonjs] export-statement-S */";
+const EXPORT_FACADE_END = "/* [vite-plugin-commonjs] export-statement-E */";
+const EXPORT_KEYWORD_RE = /\bexport\b(?!-)/;
+/** Whether `code` has a top-level ESM export statement. */
+function hasEsmExports(code) {
+	if (!EXPORT_KEYWORD_RE.test(code)) return false;
+	let ast;
+	try {
+		ast = parseAst(code);
+	} catch {
+		return false;
+	}
+	return ast.body.some((statement) => statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" || statement.type === "ExportAllDeclaration");
+}
+/**
+* Removes the export facade vite-plugin-commonjs appended to `output` when the
+* module it transformed is ESM. Returns `undefined` when there is nothing to
+* remove.
+*
+* Next.js treats a module with ESM syntax as ESM: `require()` still works, but
+* `module` / `exports` never become its exports. The plugin's analyzer is not
+* scope-aware, so for bundled ESM that inlines CommonJS wrappers
+* (`__commonJS((exports, module) => …)`) it exports the wrappers' assignments
+* too, which duplicates the module's own exports. Its `require()` rewrite and
+* its local `module` / `exports` polyfill stay, so free CommonJS assignments
+* still run without becoming exports.
+*
+* Besides the facade, the plugin only prepends imports and its polyfill and
+* rewrites `require()` calls, so the module's own top-level exports are still
+* in `output`. Classifying the output rather than rereading the source keeps
+* the decision tied to the exact code the plugin transformed.
+*
+* The facade is appended after the module's code (only dynamic-require
+* runtimes, which have no source mappings, may follow it), so removing it
+* leaves the plugin's source map valid.
+*/
+function stripEsmCommonJsExportFacade(output) {
+	const facade = findEsmCommonJsExportFacade(output);
+	return facade && output.slice(0, facade[0]) + output.slice(facade[1]);
+}
+/** The `[start, end)` range of the facade {@link stripEsmCommonJsExportFacade} removes. */
+function findEsmCommonJsExportFacade(output) {
+	const start = output.lastIndexOf(EXPORT_FACADE_START);
+	if (start === -1) return void 0;
+	const end = output.indexOf(EXPORT_FACADE_END, start);
+	if (end === -1) return void 0;
+	const facadeEnd = end + 47;
+	return hasEsmExports(output.slice(0, start) + output.slice(facadeEnd)) ? [start, facadeEnd] : void 0;
+}
+/**
+* Applies {@link stripEsmCommonJsExportFacade} in the client dependency
+* optimizer's Rolldown builds (scan and pre-bundle). vite-plugin-commonjs's
+* pre-bundle plugin loads and converts files there without vinext's transform
+* wrapper, so its output reaches this hook as the loaded code. That code is
+* the optimizer's source, so the removal needs its own map for anything the
+* plugin appended after the facade.
+*/
+const commonJsEsmFacadeOptimizeDepsPlugin = {
+	name: "vinext:commonjs-esm-facade:optimize-deps",
+	transform: {
+		filter: { code: { include: EXPORT_FACADE_START } },
+		handler(code, id) {
+			const facade = findEsmCommonJsExportFacade(code);
+			if (!facade) return null;
+			const output = new MagicString(code).remove(facade[0], facade[1]);
+			return {
+				code: output.toString(),
+				map: output.generateMap({
+					source: id,
+					hires: "boundary"
+				})
+			};
+		}
+	}
+};
+//#endregion
+export { commonJsEsmFacadeOptimizeDepsPlugin, stripEsmCommonJsExportFacade };

package/dist/plugins/commonjs-syntax.d.ts

@@ -0,0 +1,16 @@
+//#region src/plugins/commonjs-syntax.d.ts
+/**
+ * Conservative source-level superset of what vite-plugin-commonjs rewrites,
+ * as a transform `filter.code.include` list (a module matches when any
+ * pattern does; strings match as substrings).
+ *
+ * Its analyzer only acts on calls whose callee is the identifier `require` and
+ * on assignments to a member of the identifiers `module` / `exports`, and the
+ * transform returns nothing when neither is present. Text inside strings or
+ * comments can produce false positives (the module is then analyzed as
+ * before), and identifiers written with unicode escapes are never ruled out.
+ */
+export declare const COMMONJS_SYNTAX_CODE_FILTER: (string | RegExp)[];
+/** Whether `code` passes {@link COMMONJS_SYNTAX_CODE_FILTER}. */
+export declare function mayContainCommonJsSyntax(code: string): boolean;
+//#endregion

package/dist/plugins/commonjs-syntax.js

@@ -0,0 +1,22 @@
+/**
+* Conservative source-level superset of what vite-plugin-commonjs rewrites,
+* as a transform `filter.code.include` list (a module matches when any
+* pattern does; strings match as substrings).
+*
+* Its analyzer only acts on calls whose callee is the identifier `require` and
+* on assignments to a member of the identifiers `module` / `exports`, and the
+* transform returns nothing when neither is present. Text inside strings or
+* comments can produce false positives (the module is then analyzed as
+* before), and identifiers written with unicode escapes are never ruled out.
+*/
+const COMMONJS_SYNTAX_CODE_FILTER = [
+	/(?<![\w$])require(?![\w$])[\s)]*(?:\/[*/]|\(|\?\.)/,
+	"\\u",
+	/(?<![\w$]|(?<!\.)\.)(?:module|exports)(?![\w$])[\s)]*(?:\/[*/]|\??\.|\[)/
+];
+/** Whether `code` passes {@link COMMONJS_SYNTAX_CODE_FILTER}. */
+function mayContainCommonJsSyntax(code) {
+	return COMMONJS_SYNTAX_CODE_FILTER.some((pattern) => typeof pattern === "string" ? code.includes(pattern) : pattern.test(code));
+}
+//#endregion
+export { COMMONJS_SYNTAX_CODE_FILTER, mayContainCommonJsSyntax };

package/dist/plugins/fonts.d.ts

@@ -3,9 +3,10 @@ import { Plugin } from "vite";
 export declare const VIRTUAL_GOOGLE_FONTS = "virtual:vinext-google-fonts";
 export declare const RESOLVED_VIRTUAL_GOOGLE_FONTS: string;
 /**
- * Rewrite absolute filesystem paths in cached Google Fonts CSS so the
- * `@font-face { src: url(...) }` references point at the served URL the
- * plugin's `writeBundle` hook copies the font files to.
+ * Point the `@font-face { src: url(...) }` references of cached Google Fonts
+ * CSS at the served URL the plugin's `writeBundle` hook copies the font
+ * files to (and the dev middleware serves them from), by replacing
+ * `CACHED_FONT_DIR_TOKEN` with `/<assetsDir>/_vinext_fonts`.
  *
  * This is called once per transform, before the CSS string is embedded in
  * the bundle as `_vinext.font.selfHostedCSS`. Every downstream consumer reads
@@ -14,9 +15,9 @@ export declare const RESOLVED_VIRTUAL_GOOGLE_FONTS: string;
  * in `shims/font-google-base.ts`), and the HTTP `Link:` response header
  * (via `buildAppPageFontLinkHeader` in `server/app-page-execution.ts`).
  *
- * Without this rewrite, all three emit the dev-machine filesystem path
- * (e.g. `/home/user/project/.vinext/fonts/geist-<hash>/geist-<hash>.woff2`)
- * and any production request fetches `<origin>/home/user/...` → 404.
+ * The token is substituted with plain split/join: it is a fixed string
+ * vinext wrote itself, so nothing about the checkout's path (spaces, quotes,
+ * parentheses, regex metacharacters, Windows separators) is parsed here.
  *
  * `assetsDir` must match whatever Vite has resolved for
  * `build.assetsDir` on the client environment — otherwise the embedded
@@ -26,12 +27,8 @@ export declare const RESOLVED_VIRTUAL_GOOGLE_FONTS: string;
  * passes the resolved value through from plugin state. The default is
  * kept only so the exported helper can be driven directly from unit
  * tests without synthesizing a full plugin context.
- *
- * Uses split/join rather than regex because `cacheDir` is an absolute
- * filesystem path that may contain regex metacharacters on unusual
- * filesystems.
  */
-export declare function _rewriteCachedFontCssToServedUrls(css: string, cacheDir: string, assetsDir?: string): string;
+export declare function _rewriteCachedFontCssToServedUrls(css: string, assetsDir?: string): string;
 /**
  * Safely parse a static JS object literal string into a plain object.
  * Uses Vite's parseAst (Rollup/acorn) so no code is ever evaluated.

package/dist/plugins/fonts.js

@@ -43,15 +43,15 @@ const GOOGLE_FONT_UTILITY_EXPORTS = /* @__PURE__ */ new Set([
 /**
 * Served URL prefix for self-hosted Google Font files.
 *
-* `fetchAndCacheFont()` downloads .woff2 files into `<root>/.vinext/fonts/`
+* `fetchAndCacheFont()` downloads font files into `<root>/.vinext/fonts/`
 * and writes an `@font-face` CSS snippet whose `src: url(...)` references
-* the files by absolute filesystem path — convenient for disk, unusable at
-* runtime because browsers resolve relative to the origin. Before the CSS
-* is embedded in the bundle as `_vinext.font.selfHostedCSS`, the filesystem
-* prefix is rewritten to this URL prefix by `_rewriteCachedFontCssToServedUrls()`,
-* and the matching `writeBundle` hook in `createGoogleFontsPlugin` copies
-* the font files into `<clientOutDir>/<assetsDir>/_vinext_fonts/` so the
-* rewritten URL actually resolves against the origin at request time.
+* name each file relative to that cache directory, behind
+* `CACHED_FONT_DIR_TOKEN`. Before the CSS is embedded in the bundle as
+* `_vinext.font.selfHostedCSS`, `_rewriteCachedFontCssToServedUrls()`
+* replaces the token with this URL prefix, and the matching `writeBundle`
+* hook in `createGoogleFontsPlugin` copies the font files into
+* `<clientOutDir>/<assetsDir>/_vinext_fonts/` so the URL actually resolves
+* against the origin at request time.
 *
 * The leading `_` keeps the namespace distinct from Vite's content-hashed
 * asset names (which are emitted flat into `<assetsDir>/`) and from any
@@ -59,6 +59,25 @@ const GOOGLE_FONT_UTILITY_EXPORTS = /* @__PURE__ */ new Set([
 */
 const VINEXT_FONT_URL_NAMESPACE = "_vinext_fonts";
 const MAX_GOOGLE_FONTS_ERROR_BODY_LENGTH = 500;
+/**
+* Stands in for the font cache directory in every `url()` of a cached
+* stylesheet, so the file on disk holds no absolute path and reads the same
+* wherever the checkout's `.vinext/` ends up: a moved or copied project, a
+* CI cache restored into another workspace, or a Docker build that copies
+* in a host's `.vinext/`. Next.js has no such cache (its Google font loader
+* keeps fetched CSS in memory and emits `/_next/static/media` URLs), so the
+* parity target is output that does not depend on where the cache was
+* written.
+*/
+const CACHED_FONT_DIR_TOKEN = "__VINEXT_FONT_CACHE_DIR__";
+/**
+* Cached stylesheet whose `url()` references use `CACHED_FONT_DIR_TOKEN`.
+* The suffix ties the cache to that format: a `style.css` written by an
+* earlier vinext holds the writing checkout's absolute paths, which would
+* 404 once embedded, so it is never read and the font is fetched again.
+* Change the suffix whenever the cached CSS format changes.
+*/
+const CACHED_FONT_CSS_FILE = "style-q7f3kd.css";
 function formatGoogleFontsErrorBody(body) {
 	const trimmed = body.trim();
 	if (!trimmed) return "(empty response body)";
@@ -67,9 +86,10 @@ function formatGoogleFontsErrorBody(body) {
 	return `${trimmed.slice(0, MAX_GOOGLE_FONTS_ERROR_BODY_LENGTH)}\n... (truncated ${omitted} characters)`;
 }
 /**
-* Rewrite absolute filesystem paths in cached Google Fonts CSS so the
-* `@font-face { src: url(...) }` references point at the served URL the
-* plugin's `writeBundle` hook copies the font files to.
+* Point the `@font-face { src: url(...) }` references of cached Google Fonts
+* CSS at the served URL the plugin's `writeBundle` hook copies the font
+* files to (and the dev middleware serves them from), by replacing
+* `CACHED_FONT_DIR_TOKEN` with `/<assetsDir>/_vinext_fonts`.
 *
 * This is called once per transform, before the CSS string is embedded in
 * the bundle as `_vinext.font.selfHostedCSS`. Every downstream consumer reads
@@ -78,9 +98,9 @@ function formatGoogleFontsErrorBody(body) {
 * in `shims/font-google-base.ts`), and the HTTP `Link:` response header
 * (via `buildAppPageFontLinkHeader` in `server/app-page-execution.ts`).
 *
-* Without this rewrite, all three emit the dev-machine filesystem path
-* (e.g. `/home/user/project/.vinext/fonts/geist-<hash>/geist-<hash>.woff2`)
-* and any production request fetches `<origin>/home/user/...` → 404.
+* The token is substituted with plain split/join: it is a fixed string
+* vinext wrote itself, so nothing about the checkout's path (spaces, quotes,
+* parentheses, regex metacharacters, Windows separators) is parsed here.
 *
 * `assetsDir` must match whatever Vite has resolved for
 * `build.assetsDir` on the client environment — otherwise the embedded
@@ -90,16 +110,9 @@ function formatGoogleFontsErrorBody(body) {
 * passes the resolved value through from plugin state. The default is
 * kept only so the exported helper can be driven directly from unit
 * tests without synthesizing a full plugin context.
-*
-* Uses split/join rather than regex because `cacheDir` is an absolute
-* filesystem path that may contain regex metacharacters on unusual
-* filesystems.
 */
-function _rewriteCachedFontCssToServedUrls(css, cacheDir, assetsDir = DEFAULT_ASSETS_DIR) {
-	const normalizedCacheDir = toSlash(cacheDir);
-	if (!normalizedCacheDir || !css.includes(normalizedCacheDir)) return css;
-	const prefix = assetsDir || DEFAULT_ASSETS_DIR;
-	return css.split(normalizedCacheDir).join(`/${prefix}/${VINEXT_FONT_URL_NAMESPACE}`);
+function _rewriteCachedFontCssToServedUrls(css, assetsDir = DEFAULT_ASSETS_DIR) {
+	return css.split(CACHED_FONT_DIR_TOKEN).join(`/${assetsDir || DEFAULT_ASSETS_DIR}/${VINEXT_FONT_URL_NAMESPACE}`);
 }
 /**
 * Default `build.assetsDir` — matches vinext's resolved default in
@@ -274,24 +287,49 @@ function propertyNameToGoogleFontFamily(prop) {
 }
 /**
 * Fetch Google Fonts CSS, download .woff2 files, cache locally, and return
-* @font-face CSS with local file references.
+* @font-face CSS whose `url()` references use `CACHED_FONT_DIR_TOKEN`.
 *
 * Cache dir structure: .vinext/fonts/<family-hash>/
-*   - style.css (the rewritten @font-face CSS)
+*   - style-<suffix>.css (the rewritten @font-face CSS, see `CACHED_FONT_CSS_FILE`)
 *   - *.woff2 (downloaded font files)
 */
 async function fetchAndCacheFont(cssUrl, family, cacheDir) {
 	const { createHash } = await import("node:crypto");
 	const urlHash = createHash("md5").update(cssUrl).digest("hex").slice(0, 12);
-	const fontDir = path.join(cacheDir, `${family.toLowerCase().replace(/\s+/g, "-")}-${urlHash}`);
-	const cachedCSSPath = path.join(fontDir, "style.css");
+	const fontDirName = `${family.toLowerCase().replace(/\s+/g, "-")}-${urlHash}`;
+	const fontDir = path.join(cacheDir, fontDirName);
+	const cachedCSSPath = path.join(fontDir, CACHED_FONT_CSS_FILE);
 	if (fs.existsSync(cachedCSSPath)) return fs.readFileSync(cachedCSSPath, "utf-8");
+	const css = await downloadGoogleFont(cssUrl, family, fontDir, fontDirName);
+	try {
+		writeFileAtomically(cachedCSSPath, css);
+	} catch {}
+	return css;
+}
+/**
+* Write-then-rename, so a write that fails midway never leaves a partial
+* file for a later build to trust: both font files and the stylesheet are
+* reused as soon as they exist.
+*/
+function writeFileAtomically(filePath, data) {
+	const tempPath = `${filePath}.${process.pid}.tmp`;
+	try {
+		fs.writeFileSync(tempPath, data);
+		fs.renameSync(tempPath, filePath);
+	} catch (err) {
+		fs.rmSync(tempPath, { force: true });
+		throw err;
+	}
+}
+async function downloadGoogleFont(cssUrl, family, fontDir, fontDirName) {
+	const { createHash } = await import("node:crypto");
 	const cssResponse = await fetch(cssUrl, { headers: { "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36" } });
 	if (!cssResponse.ok) {
 		const body = await cssResponse.text().catch(() => "");
 		throw new GoogleFontsHttpError(cssUrl, cssResponse.status, body);
 	}
 	let css = await cssResponse.text();
+	if (!css.trim()) throw new Error(`Google Fonts returned an empty stylesheet: ${cssUrl}`);
 	const urlRe = /url\((https:\/\/fonts\.gstatic\.com\/[^)]+)\)/g;
 	const urls = /* @__PURE__ */ new Map();
 	let urlMatch;
@@ -308,14 +346,13 @@ async function fetchAndCacheFont(cssUrl, family, cacheDir) {
 		const filePath = path.join(fontDir, filename);
 		if (!fs.existsSync(filePath)) {
 			const fontResponse = await fetch(fontUrl);
-			if (fontResponse.ok) {
-				const buffer = Buffer.from(await fontResponse.arrayBuffer());
-				fs.writeFileSync(filePath, buffer);
-			}
+			if (!fontResponse.ok) throw new Error(`Font file download failed with HTTP ${fontResponse.status}: ${fontUrl}`);
+			const buffer = Buffer.from(await fontResponse.arrayBuffer());
+			if (buffer.byteLength === 0) throw new Error(`Font file download returned an empty body: ${fontUrl}`);
+			writeFileAtomically(filePath, buffer);
 		}
-		css = css.split(fontUrl).join(filePath);
+		css = css.split(fontUrl).join(`${CACHED_FONT_DIR_TOKEN}/${fontDirName}/${filename}`);
 	}
-	fs.writeFileSync(cachedCSSPath, css);
 	return css;
 }
 /**
@@ -546,7 +583,7 @@ function createGoogleFontsPlugin(fontGoogleShimPath, shimsDir) {
 						if (err instanceof GoogleFontsHttpError) throw new Error(`[vinext:google-fonts] ${id}: Google Fonts returned HTTP ${err.status} for ${err.url}.\n${formatGoogleFontsErrorBody(err.responseBody)}`);
 						return;
 					}
-					const servedCSS = _rewriteCachedFontCssToServedUrls(localCSS, cacheDir, transformAssetsDir);
+					const servedCSS = _rewriteCachedFontCssToServedUrls(localCSS, transformAssetsDir);
 					const preloadUrls = findFontFilesInCss(servedCSS, validated.preload ? validated.subsets : void 0).filter((file) => file.preloadFontFile).map((file) => file.googleFontFileUrl);
 					const fallbackMetrics = validated.adjustFontFallback === false ? void 0 : getFallbackFontOverrideMetrics(family);
 					const adjustedFallbackCSS = fallbackMetrics ? buildFallbackFontFace(family, fallbackMetrics) : void 0;

package/dist/plugins/ignore-dynamic-requests.d.ts

@@ -1,7 +1,18 @@
 import { MagicStringTransformResult } from "./transform-result.js";
 import { Plugin } from "vite";
 //#region src/plugins/ignore-dynamic-requests.d.ts
+/**
+ * Cheap, conservative check run before parsing: whether any `require` or
+ * `import` occurrence could be a request this transform rewrites. Occurrences
+ * that are part of a longer identifier, member properties, static imports,
+ * non-callee positions (`typeof require`, `require,`), and calls with a
+ * single-line string literal argument other than "/" are left unchanged, so a
+ * module containing only those is skipped. Anything else, including escaped
+ * identifiers, falls through to the AST pass.
+ */
+declare function mayContainVeryDynamicRequest(code: string): boolean;
 declare function transformVeryDynamicRequests(code: string, id: string): MagicStringTransformResult | null;
 export declare function createIgnoreDynamicRequestsPlugin(getTranspiledPackages?: () => readonly string[]): Plugin;
 export declare const _transformVeryDynamicRequests: typeof transformVeryDynamicRequests;
+export declare const _mayContainVeryDynamicRequest: typeof mayContainVeryDynamicRequest;
 //#endregion