vinext 1.2.1 → 1.3.1

package/dist/init.js

@@ -2,6 +2,7 @@ import path, { toSlash } from "./deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/
 import { detectPackageManager, detectPackageManagerName, detectProject, ensureESModule, findViteConfigPath, hasViteConfig, renameCJSConfigs } from "./utils/project.js";
 import { compactResourceName, cssModulesConfigSource, findConfigKeepingWorkerName, setupCloudflarePlatform, updateViteConfigForCssModules, usesCommonJsViteConfig, validateCloudflarePlatformSetup } from "./init-cloudflare.js";
 import { getReactUpgradeDeps } from "./utils/react-version.js";
+import { getPluginReactUpgradeDeps } from "./utils/plugin-react-version.js";
 import fs from "node:fs";
 import { spawn, spawnSync } from "node:child_process";
 //#region src/init.ts
@@ -598,6 +599,22 @@ async function init(options) {
 			}
 		}
 	}
+	const pluginReactUpgrade = getPluginReactUpgradeDeps(root);
+	if (pluginReactUpgrade.length > 0) {
+		console.log(`  ${terminalStyle.cyan(terminalStyle.bold("Upgrading devDependencies:"))}`);
+		console.log(formatList(pluginReactUpgrade.map((dep) => dep.replace(/@latest$/, "")), "    "));
+		try {
+			if (shouldInstall) {
+				if (isApproveBuildsError(await installDeps(root, pluginReactUpgrade, exec))) dependencyInstallNeedsApproval = true;
+			} else {
+				const added = addDependencyEntries(root, pluginReactUpgrade, { dev: true });
+				devDependencyEntriesAdded.push(...added);
+			}
+		} catch (error) {
+			if (pmName !== "pnpm" || !isApproveBuildsError(error)) throw error;
+			dependencyInstallNeedsApproval = true;
+		}
+	}
 	if (missingDependencies.length > 0) {
 		console.log(`  ${terminalStyle.cyan(terminalStyle.bold("Installing dependencies:"))}`);
 		console.log(formatList(missingDependencies, "    "));

package/dist/plugins/client-compile-hints.d.ts

@@ -0,0 +1,30 @@
+import { Plugin } from "vite";
+//#region src/plugins/client-compile-hints.d.ts
+/**
+ * V8's file-level explicit compile hint (Chrome 136+). V8 compiles every
+ * function in a file that starts with this comment eagerly, on the background
+ * thread that streams the script, instead of lazily on the main thread the
+ * first time each function runs. Other engines ignore it.
+ * https://v8.dev/blog/explicit-compile-hints
+ */
+export declare const CLIENT_COMPILE_HINT = "//# allFunctionsCalledOnLoad";
+/**
+ * Marks the client chunks every page load runs with V8's compile hint.
+ *
+ * Those are the browser entry chunks and the chunks they import statically:
+ * React, React DOM, the Flight client and the vinext runtime. Hydration calls
+ * most of their functions on load, so lazy compilation only moves that work
+ * onto the main thread. Chunks reached through dynamic imports (route code,
+ * lazy client references, navigation-only modules) keep lazy compilation,
+ * since eagerly compiling code a page may never call costs time and memory.
+ *
+ * The hint has to be the first line of the file, so it is added in the last
+ * generateBundle pass, after minification and after Vite's import analysis
+ * prepends its `__vite__mapDeps` preload helper. That pass runs after Rolldown
+ * hashes file names, so `augmentChunkHash` salts the hash of every chunk that
+ * gets the hint: a hinted file never reuses the URL of an unhinted one, which
+ * browsers may hold as immutable. Its sourcemap keeps following the chunk's
+ * name, so builds that name sourcemaps themselves are left alone.
+ */
+export declare function createClientCompileHintsPlugin(isBrowserEntry: (id: string) => boolean): Plugin;
+//#endregion

package/dist/plugins/client-compile-hints.js

@@ -0,0 +1,88 @@
+//#region src/plugins/client-compile-hints.ts
+/**
+* V8's file-level explicit compile hint (Chrome 136+). V8 compiles every
+* function in a file that starts with this comment eagerly, on the background
+* thread that streams the script, instead of lazily on the main thread the
+* first time each function runs. Other engines ignore it.
+* https://v8.dev/blog/explicit-compile-hints
+*/
+const CLIENT_COMPILE_HINT = "//# allFunctionsCalledOnLoad";
+/** Shifts a sourcemap down one generated line, for a line added at the top. */
+function shiftSourceMapSource(source) {
+	const text = typeof source === "string" ? source : new TextDecoder().decode(source);
+	const map = JSON.parse(text);
+	map.mappings = ";" + map.mappings;
+	return JSON.stringify(map);
+}
+/**
+* Marks the client chunks every page load runs with V8's compile hint.
+*
+* Those are the browser entry chunks and the chunks they import statically:
+* React, React DOM, the Flight client and the vinext runtime. Hydration calls
+* most of their functions on load, so lazy compilation only moves that work
+* onto the main thread. Chunks reached through dynamic imports (route code,
+* lazy client references, navigation-only modules) keep lazy compilation,
+* since eagerly compiling code a page may never call costs time and memory.
+*
+* The hint has to be the first line of the file, so it is added in the last
+* generateBundle pass, after minification and after Vite's import analysis
+* prepends its `__vite__mapDeps` preload helper. That pass runs after Rolldown
+* hashes file names, so `augmentChunkHash` salts the hash of every chunk that
+* gets the hint: a hinted file never reuses the URL of an unhinted one, which
+* browsers may hold as immutable. Its sourcemap keeps following the chunk's
+* name, so builds that name sourcemaps themselves are left alone.
+*/
+function createClientCompileHintsPlugin(isBrowserEntry) {
+	const startupByEnvironment = /* @__PURE__ */ new WeakMap();
+	const startupChunks = (environment) => (environment && startupByEnvironment.get(environment)?.chunks) ?? void 0;
+	return {
+		name: "vinext:client-compile-hints",
+		apply: "build",
+		enforce: "post",
+		renderStart(outputOptions) {
+			const environment = this.environment;
+			if (environment?.name !== "client") return;
+			const { codeSplitting, sourcemap, sourcemapFileNames } = outputOptions;
+			if (!codeSplitting || sourcemap === "inline" || sourcemap && sourcemapFileNames !== void 0) {
+				startupByEnvironment.delete(environment);
+				return;
+			}
+			startupByEnvironment.set(environment, { chunks: null });
+		},
+		renderChunk(_code, _chunk, _options, meta) {
+			const state = this.environment && startupByEnvironment.get(this.environment);
+			if (!state || state.chunks) return null;
+			const startup = /* @__PURE__ */ new Set();
+			const pending = [];
+			for (const chunk of Object.values(meta.chunks)) if (chunk.isEntry && chunk.facadeModuleId !== null && isBrowserEntry(chunk.facadeModuleId)) pending.push(chunk.fileName);
+			for (let fileName = pending.pop(); fileName !== void 0; fileName = pending.pop()) {
+				const chunk = meta.chunks[fileName];
+				if (startup.has(fileName) || !chunk) continue;
+				startup.add(fileName);
+				pending.push(...chunk.imports);
+			}
+			state.chunks = startup;
+			return null;
+		},
+		augmentChunkHash(chunk) {
+			if (startupChunks(this.environment)?.has(chunk.fileName)) return CLIENT_COMPILE_HINT;
+		},
+		generateBundle: {
+			order: "post",
+			handler(options, bundle) {
+				const startup = startupChunks(this.environment);
+				if (!startup) return;
+				for (const chunk of Object.values(bundle)) {
+					if (chunk.type !== "chunk" || !startup.has(chunk.preliminaryFileName)) continue;
+					chunk.code = `${CLIENT_COMPILE_HINT}\n${chunk.code}`;
+					if (!options.sourcemap) continue;
+					if (chunk.map) chunk.map.mappings = ";" + chunk.map.mappings;
+					const mapAsset = chunk.sourcemapFileName ? bundle[chunk.sourcemapFileName] : void 0;
+					if (mapAsset?.type === "asset") mapAsset.source = shiftSourceMapSource(mapAsset.source);
+				}
+			}
+		}
+	};
+}
+//#endregion
+export { CLIENT_COMPILE_HINT, createClientCompileHintsPlugin };

package/dist/plugins/client-reference-dedup.d.ts

@@ -30,4 +30,5 @@ export declare function extractPackageImportSpecifier(absolutePath: string, read
  * Dev-only — production builds use the SSR manifest which handles this correctly.
  */
 export declare function clientReferenceDedupPlugin(options?: ClientReferenceDedupOptions): Plugin;
-//#endregion
+//#endregion
+export {};

package/dist/plugins/cloudflare-dev-module-urls.d.ts

@@ -38,4 +38,5 @@ type CloudflareDevModuleUrlsOptions = {
  * @returns The Vite plugin
  */
 export declare function createCloudflareDevModuleUrlsPlugin(options: CloudflareDevModuleUrlsOptions): Plugin;
-//#endregion
+//#endregion
+export {};

package/dist/plugins/dynamic-preload-metadata.d.ts

@@ -6,6 +6,8 @@ type TransformResult = {
   map: ReturnType<MagicString["generateMap"]>;
 };
 type ResolveDynamicImport = (specifier: string, importer: string) => Promise<string | null>;
+export declare function toManifestModuleId(root: string, resolvedId: string): string | null;
 export declare function transformNextDynamicPreloadMetadata(code: string, id: string, root: string, resolveDynamicImport: ResolveDynamicImport): Promise<TransformResult | null>;
 export declare function createDynamicPreloadMetadataPlugin(getTranspiledPackages: () => readonly string[]): Plugin;
-//#endregion
+//#endregion
+export {};

package/dist/plugins/dynamic-preload-metadata.js

@@ -290,4 +290,4 @@ function createDynamicPreloadMetadataPlugin(getTranspiledPackages) {
 	};
 }
 //#endregion
-export { createDynamicPreloadMetadataPlugin, transformNextDynamicPreloadMetadata };
+export { createDynamicPreloadMetadataPlugin, toManifestModuleId, transformNextDynamicPreloadMetadata };

package/dist/plugins/environment.d.ts

@@ -7,4 +7,5 @@ type PluginEnvironment = {
 };
 /** Whether a Vite environment produces server-consumed output. */
 export declare function isServerEnvironment(environment: PluginEnvironment): boolean;
-//#endregion
+//#endregion
+export {};

package/dist/plugins/fonts.js

@@ -74,10 +74,12 @@ 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.
+* 404 once embedded, and a `style-q7f3kd.css` names extensionless Google
+* font URLs `.ttf` whatever their format, so neither is read and the font
+* is fetched again. Change the suffix whenever the cached CSS format
+* changes.
 */
-const CACHED_FONT_CSS_FILE = "style-q7f3kd.css";
+const CACHED_FONT_CSS_FILE = "style-h8r2vn.css";
 function formatGoogleFontsErrorBody(body) {
 	const trimmed = body.trim();
 	if (!trimmed) return "(empty response body)";
@@ -330,16 +332,11 @@ async function downloadGoogleFont(cssUrl, family, fontDir, fontDirName) {
 	}
 	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;
-	while ((urlMatch = urlRe.exec(css)) !== null) {
-		const fontUrl = urlMatch[1];
-		if (!urls.has(fontUrl)) {
-			const ext = fontUrl.includes(".woff2") ? ".woff2" : fontUrl.includes(".woff") ? ".woff" : ".ttf";
-			const fileHash = createHash("md5").update(fontUrl).digest("hex").slice(0, 8);
-			urls.set(fontUrl, `${family.toLowerCase().replace(/\s+/g, "-")}-${fileHash}${ext}`);
-		}
+	for (const { googleFontFileUrl: fontUrl, ext } of findFontFilesInCss(css)) {
+		if (!fontUrl.startsWith("https://fonts.gstatic.com/")) continue;
+		const fileHash = createHash("md5").update(fontUrl).digest("hex").slice(0, 8);
+		urls.set(fontUrl, `${family.toLowerCase().replace(/\s+/g, "-")}-${fileHash}.${ext}`);
 	}
 	fs.mkdirSync(fontDir, { recursive: true });
 	for (const [fontUrl, filename] of urls) {

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

@@ -15,4 +15,5 @@ declare function transformVeryDynamicRequests(code: string, id: string): MagicSt
 export declare function createIgnoreDynamicRequestsPlugin(getTranspiledPackages?: () => readonly string[]): Plugin;
 export declare const _transformVeryDynamicRequests: typeof transformVeryDynamicRequests;
 export declare const _mayContainVeryDynamicRequest: typeof mayContainVeryDynamicRequest;
-//#endregion
+//#endregion
+export {};

package/dist/plugins/import-meta-url.d.ts

@@ -17,4 +17,5 @@ export declare function createImportMetaUrlPlugin(options: {
 }): ImportMetaUrlCapability;
 export declare function rewriteImportMetaUrl(code: string, id: string, root: string, environment: ImportMetaUrlEnvironment): MagicStringTransformResult | null;
 export declare function rewriteServerCjsGlobals(code: string, id: string, root: string): MagicStringTransformResult | null;
-//#endregion
+//#endregion
+export {};

package/dist/plugins/og-assets.d.ts

@@ -63,4 +63,5 @@ export declare function copyMissingOgWasm(opts: {
  * target — so it helps Node/self-hosted builds as well as Cloudflare Workers.
  */
 export declare function createOgAssetsPlugin(): Plugin;
-//#endregion
+//#endregion
+export {};

package/dist/plugins/og-assets.js

@@ -37,9 +37,8 @@ function createOgInlineFetchAssetsPlugin() {
 				...options,
 				skipSelf: true
 			});
-			if (resolved === null || resolved.external) return null;
-			await ownership.recordResolvedImport(source, resolved.id);
-			return null;
+			if (resolved !== null && !resolved.external) await ownership.recordResolvedImport(source, resolved.id);
+			return options.kind === "require-call" ? null : resolved;
 		},
 		transform: {
 			filter: { code: "import.meta.url" },

package/dist/plugins/optimize-imports.d.ts

@@ -5,16 +5,39 @@ type BarrelExportEntry = {
   source: string;
   isNamespace: boolean;
   originalName?: string;
+  /**
+   * The outermost module on the way to `source` that RSC replaces with
+   * references or wrappers because of its directive. RSC must import the name
+   * from it instead.
+   */
+  rscBoundary?: string;
+  /**
+   * The same for SSR, where only "use server" and "use cache" modules are
+   * replaced with references.
+   */
+  ssrBoundary?: string;
 };
 type BarrelExportMap = Map<string, BarrelExportEntry>;
 /**
  * Packages whose barrel imports are automatically optimized.
  * Matches Next.js's built-in optimizePackageImports defaults plus vinext-specific
- * compatibility entries for radix-ui and @chakra-ui/react.
+ * compatibility entries for radix-ui, @chakra-ui/react, and @heroui/react.
  * @see https://github.com/vercel/next.js/blob/9c31bbdaa/packages/next/src/server/config.ts#L1301
  */
 export declare const DEFAULT_OPTIMIZE_PACKAGES: string[];
-export declare function createOptimizedImportSourceMatcher(packages: Iterable<string>): (code: string) => boolean;
+/**
+ * Packages whose subpath imports (`pkg/Sub`) are also optimized, in the RSC
+ * environment only. Their subpath entries are themselves barrels: heroui's
+ * Toast imports `UNSTABLE_ToastQueue` from "react-aria-components/Toast", whose
+ * other exports call createContext() at module scope and import "client-only"
+ * (https://github.com/cloudflare/vinext/issues/4007). Like Next.js's default
+ * Turbopack build, this drops the side-effect-free entry's "client-only"
+ * import: server-safe exports work, and client components still fail when
+ * their own modules are evaluated. SSR and the client keep the package's own
+ * module graph, so context modules are never instantiated twice there.
+ */
+export declare const SUBPATH_OPTIMIZE_PACKAGES: string[];
+export declare function createOptimizedImportSourceMatcher(packages: Iterable<string>, subpathPackages?: Iterable<string>): (code: string) => boolean;
 /**
  * Build a map of exported names → source sub-module for a barrel package.
  *
@@ -38,4 +61,5 @@ export declare function buildBarrelExportMap(entryPath: string | null, readFile:
  * @param getRoot - Returns the current project root (set by the vinext:config hook).
  */
 export declare function createOptimizeImportsPlugin(getNextConfig: () => ResolvedNextConfig | undefined, getRoot: () => string): Plugin;
-//#endregion
+//#endregion
+export {};

package/dist/plugins/optimize-imports.js

@@ -21,7 +21,7 @@ async function readFileSafe(filepath) {
 /**
 * Packages whose barrel imports are automatically optimized.
 * Matches Next.js's built-in optimizePackageImports defaults plus vinext-specific
-* compatibility entries for radix-ui and @chakra-ui/react.
+* compatibility entries for radix-ui, @chakra-ui/react, and @heroui/react.
 * @see https://github.com/vercel/next.js/blob/9c31bbdaa/packages/next/src/server/config.ts#L1301
 */
 const DEFAULT_OPTIMIZE_PACKAGES = [
@@ -101,10 +101,40 @@ const DEFAULT_OPTIMIZE_PACKAGES = [
 	"react-icons/ti",
 	"react-icons/vsc",
 	"react-icons/wi",
-	"radix-ui"
+	"radix-ui",
+	"@heroui/react"
 ];
-function createOptimizedImportSourceMatcher(packages) {
-	const pattern = [...packages].map(escapeRegExp).join("|");
+/**
+* Packages whose subpath imports (`pkg/Sub`) are also optimized, in the RSC
+* environment only. Their subpath entries are themselves barrels: heroui's
+* Toast imports `UNSTABLE_ToastQueue` from "react-aria-components/Toast", whose
+* other exports call createContext() at module scope and import "client-only"
+* (https://github.com/cloudflare/vinext/issues/4007). Like Next.js's default
+* Turbopack build, this drops the side-effect-free entry's "client-only"
+* import: server-safe exports work, and client components still fail when
+* their own modules are evaluated. SSR and the client keep the package's own
+* module graph, so context modules are never instantiated twice there.
+*/
+const SUBPATH_OPTIMIZE_PACKAGES = ["react-aria-components"];
+function isOptimizedSubpath(source, subpathPackages) {
+	for (const pkg of subpathPackages) if (source.length > pkg.length + 1 && source.startsWith(`${pkg}/`)) return true;
+	return false;
+}
+/**
+* Return the directive that marks a module as an RSC boundary, if any.
+* Re-exports must not be followed through such a module: importing its leaves
+* directly would bypass the client reference, server reference, or cache wrapper.
+*/
+function findBoundaryDirective(ast) {
+	for (const statement of ast.body) {
+		if (statement.type !== "ExpressionStatement" || typeof statement.directive !== "string") return null;
+		const directive = statement.directive;
+		if (directive === "use client" || directive === "use server" || directive.startsWith("use cache")) return directive;
+	}
+	return null;
+}
+function createOptimizedImportSourceMatcher(packages, subpathPackages = []) {
+	const pattern = [...[...packages].map(escapeRegExp), ...[...subpathPackages].map((pkg) => String.raw`${escapeRegExp(pkg)}/[^"'\s]+`)].join("|");
 	if (!pattern) return () => false;
 	const importFromPattern = new RegExp(String.raw`(?:^|[;}\n\r])\s*import(?!\s*\()(?:(?!\bfrom\b)[\s\S])*?\bfrom\s*["'](?:${pattern})["']`, "m");
 	const quotedSourcePattern = new RegExp(String.raw`["'](?:${pattern})["']`);
@@ -238,6 +268,7 @@ async function buildExportMapFromFile(filePath, readFile, cache, visited, initia
 		return /* @__PURE__ */ new Map();
 	}
 	const exportMap = /* @__PURE__ */ new Map();
+	const boundaryDirective = findBoundaryDirective(ast);
 	const importBindings = /* @__PURE__ */ new Map();
 	const localDeclarations = /* @__PURE__ */ new Set();
 	const fileDir = path.dirname(filePath);
@@ -379,6 +410,14 @@ async function buildExportMapFromFile(filePath, readFile, cache, visited, initia
 			break;
 		}
 	}
+	if (boundaryDirective) {
+		const isSsrBoundary = boundaryDirective !== "use client";
+		for (const [name, entry] of exportMap) exportMap.set(name, {
+			...entry,
+			rscBoundary: filePath,
+			ssrBoundary: isSsrBoundary ? filePath : entry.ssrBoundary
+		});
+	}
 	cache.set(filePath, exportMap);
 	return exportMap;
 }
@@ -407,6 +446,15 @@ async function buildBarrelExportMap(entryPath, readFile, cache) {
 	return await buildExportMapFromFile(entryPath, readFile, exportMapCache, /* @__PURE__ */ new Set(), content);
 }
 /**
+* Resolve a specifier with Vite's resolver, returning the id only when it is a
+* file in the module graph (not external or virtual).
+*/
+async function resolveFileId(ctx, source, importer) {
+	const resolved = await ctx.resolve(source, importer, { skipSelf: true });
+	if (!resolved || resolved.external || !path.isAbsolute(resolved.id)) return null;
+	return resolved.id;
+}
+/**
 * Creates the vinext:optimize-imports Vite plugin.
 *
 * @param nextConfig - Resolved Next.js config (may be undefined before config hook runs).
@@ -420,6 +468,7 @@ function createOptimizeImportsPlugin(getNextConfig, getRoot) {
 	const entryPathCache = /* @__PURE__ */ new Map();
 	let optimizedPackages = /* @__PURE__ */ new Set();
 	let hasOptimizedImportSource = () => false;
+	let hasOptimizedRscImportSource = () => false;
 	const registeredBarrels = /* @__PURE__ */ new Set();
 	return {
 		name: "vinext:optimize-imports",
@@ -427,6 +476,7 @@ function createOptimizeImportsPlugin(getNextConfig, getRoot) {
 			const nextConfig = getNextConfig();
 			optimizedPackages = /* @__PURE__ */ new Set([...DEFAULT_OPTIMIZE_PACKAGES, ...nextConfig?.optimizePackageImports ?? []]);
 			hasOptimizedImportSource = createOptimizedImportSourceMatcher(optimizedPackages);
+			hasOptimizedRscImportSource = createOptimizedImportSourceMatcher(optimizedPackages, SUBPATH_OPTIMIZE_PACKAGES);
 			entryPathCache.clear();
 			barrelCaches.exportMapCache.clear();
 			barrelCaches.subpkgOrigin.clear();
@@ -434,56 +484,77 @@ function createOptimizeImportsPlugin(getNextConfig, getRoot) {
 		},
 		async resolveId(source) {
 			if (this.environment?.name === "client") return;
-			const envName = this.environment?.name ?? "ssr";
-			const barrelEntry = barrelCaches.subpkgOrigin.get(envName)?.get(source) ?? barrelCaches.subpkgOrigin.get(envName === "rsc" ? "ssr" : "rsc")?.get(source);
+			const envKey = this.environment?.name === "rsc" ? "rsc" : "ssr";
+			const barrelEntry = barrelCaches.subpkgOrigin.get(envKey)?.get(source);
 			if (!barrelEntry) return;
 			return await this.resolve(source, barrelEntry, { skipSelf: true }) ?? void 0;
 		},
 		transform: {
 			filter: {
 				id: {
-					include: /\.(tsx?|jsx?|mjs)$/,
+					include: /\.(tsx?|jsx?|mjs)(?:\?v=\w+)?$/,
 					exclude: VIRTUAL_MODULE_ID_RE
 				},
 				code: /\bimport\b[\s\S]*\bfrom\b/
 			},
-			async handler(code) {
+			async handler(code, id) {
 				const env = this.environment;
 				if (env?.name === "client") return null;
 				const preferReactServer = env?.name === "rsc";
 				const packages = optimizedPackages;
-				if (!hasOptimizedImportSource(code)) return null;
+				if (!(preferReactServer ? hasOptimizedRscImportSource : hasOptimizedImportSource)(code)) return null;
 				let ast;
 				try {
 					ast = parseProgram(code);
 				} catch {
 					return null;
 				}
+				if (preferReactServer && findBoundaryDirective(ast) === "use client") return null;
 				const s = new MagicString(code);
 				let hasChanges = false;
 				const root = getRoot();
 				for (const node of ast.body) {
 					if (node.type !== "ImportDeclaration") continue;
 					const importSource = typeof node.source?.value === "string" ? node.source.value : null;
-					if (!importSource || !packages.has(importSource)) continue;
-					const cacheKey = `${preferReactServer ? "rsc" : "ssr"}:${importSource}`;
-					let barrelEntry = entryPathCache.get(cacheKey);
-					if (barrelEntry === void 0) {
-						barrelEntry = await resolvePackageEntry(importSource, root, preferReactServer);
-						entryPathCache.set(cacheKey, barrelEntry ?? null);
+					if (!importSource) continue;
+					const isSubpath = !packages.has(importSource) && preferReactServer && isOptimizedSubpath(importSource, SUBPATH_OPTIMIZE_PACKAGES);
+					if (!isSubpath && !packages.has(importSource)) continue;
+					let barrelEntry;
+					if (isSubpath) {
+						barrelEntry = await resolveFileId(this, importSource, id);
+						if (barrelEntry) barrelEntry = barrelEntry.replace(/\?.*$/, "");
+					} else {
+						const cacheKey = `${preferReactServer ? "rsc" : "ssr"}:${importSource}`;
+						barrelEntry = entryPathCache.get(cacheKey);
+						if (barrelEntry === void 0) {
+							barrelEntry = await resolvePackageEntry(importSource, root, preferReactServer);
+							entryPathCache.set(cacheKey, barrelEntry ?? null);
+						}
 					}
 					const exportMap = await buildBarrelExportMap(barrelEntry, readFileSafe, barrelCaches.exportMapCache);
 					if (!exportMap || !barrelEntry) continue;
+					const getEntry = (name) => {
+						const entry = exportMap.get(name);
+						const boundary = preferReactServer ? entry?.rscBoundary : entry?.ssrBoundary;
+						return boundary ? {
+							source: boundary,
+							isNamespace: false,
+							originalName: name
+						} : entry;
+					};
 					const envKey = preferReactServer ? "rsc" : "ssr";
 					const registeredKey = `${envKey}:${barrelEntry}`;
-					if (!registeredBarrels.has(registeredKey)) {
+					if (!isSubpath && !registeredBarrels.has(registeredKey)) {
 						registeredBarrels.add(registeredKey);
 						let envOriginMap = barrelCaches.subpkgOrigin.get(envKey);
 						if (!envOriginMap) {
 							envOriginMap = /* @__PURE__ */ new Map();
 							barrelCaches.subpkgOrigin.set(envKey, envOriginMap);
 						}
-						for (const entry of exportMap.values()) if (!entry.source.startsWith("/") && !entry.source.startsWith(".") && !envOriginMap.has(entry.source)) envOriginMap.set(entry.source, barrelEntry);
+						for (const name of exportMap.keys()) {
+							const source = getEntry(name).source;
+							if (!source.startsWith("/") && !source.startsWith(".") && !envOriginMap.has(source)) envOriginMap.set(source, barrelEntry);
+						}
 					}
 					const specifiers = [];
 					let allResolved = true;
@@ -528,11 +599,26 @@ function createOptimizeImportsPlugin(getNextConfig, getRoot) {
 						}
 						continue;
 					}
+					if (isSubpath && specifiers.every(({ imported }) => getEntry(imported)?.source === barrelEntry)) continue;
+					const resolvedPackageSources = /* @__PURE__ */ new Map();
+					if (isSubpath) {
+						for (const { imported } of specifiers) {
+							const source = getEntry(imported)?.source;
+							if (!source || path.isAbsolute(source) || resolvedPackageSources.has(source)) continue;
+							const resolvedId = await resolveFileId(this, source, barrelEntry);
+							if (!resolvedId) {
+								allResolved = false;
+								break;
+							}
+							resolvedPackageSources.set(source, resolvedId);
+						}
+						if (!allResolved) continue;
+					}
 					const bySource = /* @__PURE__ */ new Map();
 					for (const { local, imported } of specifiers) {
-						const entry = exportMap.get(imported);
+						const entry = getEntry(imported);
 						if (!entry) continue;
-						const resolvedSource = entry.source;
+						const resolvedSource = resolvedPackageSources.get(entry.source) ?? entry.source;
 						const key = `${resolvedSource}::${entry.isNamespace}`;
 						let group = bySource.get(key);
 						if (!group) {
@@ -569,4 +655,4 @@ function createOptimizeImportsPlugin(getNextConfig, getRoot) {
 	};
 }
 //#endregion
-export { DEFAULT_OPTIMIZE_PACKAGES, buildBarrelExportMap, createOptimizeImportsPlugin, createOptimizedImportSourceMatcher };
+export { DEFAULT_OPTIMIZE_PACKAGES, SUBPATH_OPTIMIZE_PACKAGES, buildBarrelExportMap, createOptimizeImportsPlugin, createOptimizedImportSourceMatcher };

package/dist/plugins/pages-node-externals.d.ts

@@ -19,4 +19,5 @@ type PagesNodeExternalsOptions = {
  * selected `import` export just like Turbopack.
  */
 export declare function createPagesNodeExternalsPlugin(options: PagesNodeExternalsOptions): Plugin;
-//#endregion
+//#endregion
+export {};

package/dist/plugins/remove-console.d.ts

@@ -16,4 +16,5 @@ type RemoveConsoleResult = {
  * Returns `null` if no console calls are removed.
  */
 export declare function removeConsoleCalls(code: string, config: RemoveConsoleConfig): RemoveConsoleResult | null;
-//#endregion
+//#endregion
+export {};

package/dist/plugins/require-condition-resolution.d.ts

@@ -12,4 +12,5 @@ export declare function isConditionalRequireScriptModuleId(id: string): boolean;
 type IdResolverFactory = typeof createIdResolver;
 type CommonJsTransformFilter = (id: string) => boolean | undefined;
 export declare function createRequireConditionResolutionPlugin(createResolver?: IdResolverFactory, commonjsTransformFilter?: CommonJsTransformFilter): Plugin;
-//#endregion
+//#endregion
+export {};

package/dist/plugins/rsc-client-reference-loaders.d.ts

@@ -1,4 +1,56 @@
+import { AppRoute } from "../routing/app-route-graph.js";
 import { Plugin } from "vite";
 //#region src/plugins/rsc-client-reference-loaders.d.ts
-export declare function createRscClientReferenceLoadersPlugin(): Plugin;
+/** Prefixes the module that registers one client reference outside every group. */
+export declare const RESOLVED_CLIENT_REFERENCE_MODULE_PREFIX = "\0virtual:vinext-client-reference-module/";
+export declare const RESOLVED_CLIENT_REFERENCE_CHUNKS_ID = "\0virtual:vinext-client-reference-chunks";
+export type RscClientReferenceRouteOptions = {
+  /** Maps route file paths to the module ids used by the RSC module graph. */
+  canonicalizeModuleId: (id: string) => string;
+  /** App Router routes of the current build, or null outside App Router builds. */
+  getRoutes: () => readonly AppRoute[] | null;
+  /**
+   * Files any route's render can show: global-error, and the root boundaries
+   * that routes without their own not-found, forbidden or unauthorized use.
+   */
+  getAlwaysRenderedFiles: () => readonly string[];
+  /**
+   * The files a render without a route (a route-miss 404) shows: the root
+   * layouts and boundaries, and global-not-found.
+   */
+  getRoutelessFiles: () => readonly string[];
+  /** Route-independent roots such as global-error and global-not-found. */
+  getSharedRoots: () => readonly string[];
+};
+export type RscClientReferenceGroupingOptions = {
+  /** Modules that live in chunks every page loads anyway (React, vinext runtime). */
+  isAlwaysLoadedClientModule: (id: string) => boolean;
+  /** vinext's own client chunk groups. Any other chunk group disables grouping. */
+  ownClientChunkGroups: ReadonlySet<unknown>;
+};
+/**
+ * Replaces @vitejs/plugin-rsc's client-reference facades with per-reference
+ * loaders. With `routes`, the SSR build also exports the client references
+ * each App Router route preloads. With `grouping`, production client builds
+ * additionally load references that the same App Router routes reach through
+ * one shared route group module (see build/client-reference-groups.ts), so a
+ * page fetches one chunk per route group instead of one per `"use client"`
+ * module.
+ */
+export declare function createRscClientReferenceLoadersPlugin(options?: {
+  routes?: RscClientReferenceRouteOptions;
+  grouping?: RscClientReferenceGroupingOptions;
+  /**
+   * Receives the client build's client reference modules: each resolved
+   * module id with the keys of the references it registers.
+   */
+  onClientReferenceModules?: (modules: ReadonlyMap<string, readonly string[]>) => void;
+}): Plugin;
+/**
+ * Exports a null preload plan from the client-references virtual module when
+ * the app registers @vitejs/plugin-rsc itself (`rsc: false`), where vinext
+ * doesn't add the loaders plugin above. The App Router SSR entry imports the
+ * plan, and null makes it preload every client reference.
+ */
+export declare function createRouteClientReferencesFallbackPlugin(): Plugin;
 //#endregion