vinext 1.2.1 → 1.3.1

package/README.md

@@ -232,6 +232,8 @@ The migration is non-destructive -- your existing Next.js setup continues to wor
 
 vinext targets Vite 8, which defaults to Rolldown, Oxc, Lightning CSS, and a newer browser baseline. If you bring custom Vite config or plugins from an older setup, prefer `oxc`, `optimizeDeps.rolldownOptions`, and `build.rolldownOptions` over older `esbuild` and `build.rollupOptions` knobs, and override `build.target` if you still need older browsers. If a dependency breaks because of stricter CommonJS default import handling, fix the import or use `legacy.inconsistentCjsInterop: true` as a temporary escape hatch. See the [Vite 8 migration guide](https://vite.dev/guide/migration).
 
+Production client JS, Web Worker and CSS files use hash-only file names (by default `_next/static/chunks/[hash].js`, `_next/static/workers/<module-id>-[hash].js` and `_next/static/css/[hash].css`) so component and source file names don't appear in public asset URLs. Web Worker file names are fixed. To use different client JS and CSS names, set `entryFileNames`, `chunkFileNames` or `assetFileNames` in `build.rolldownOptions.output` (or `environments.client.build.rolldownOptions.output`), keeping them under the client assets directory: `_next/static/` by default, or `<prefix>/_next/static/` with a path-based `assetPrefix` such as `/cdn` (e.g. `chunkFileNames: "cdn/_next/static/chunks/[name]-[hash].js"`).
+
 ```bash
 npm run dev:vinext    # Start the vinext dev server (port 3001)
 npm run build:vinext  # Build production output with vinext
@@ -677,15 +679,16 @@ Every `next/*` import is shimmed to a Vite-compatible implementation.
 
 ### Configuration
 
-| Feature                                          |     | Notes                                                                                                                                                                                                                  |
-| ------------------------------------------------ | --- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `next.config.js` / `.ts` / `.mjs`                | ✅  | Function configs, phase argument                                                                                                                                                                                       |
-| `rewrites` / `redirects` / `headers`             | ✅  | All phases, param interpolation                                                                                                                                                                                        |
-| Environment variables (`.env*`, `NEXT_PUBLIC_*`) | ✅  | Auto-loads Next.js-style dotenv files; only public vars are inlined                                                                                                                                                    |
-| `images` config                                  | 🟡  | Parsed but not used for optimization                                                                                                                                                                                   |
-| `experimental.optimizePackageImports`            | ✅  | Rewrites barrel imports to direct sub-module imports in RSC/SSR environments. A default set (lucide-react, date-fns, radix-ui, antd, MUI, and others) are always optimized. Add package names here to extend the list. |
-| `vinext({ nextConfig })`                         | ✅  | Inline Next-style config from `vite.config.*`. Supports object-form and function-form config. When provided, this overrides root `next.config.*`.                                                                      |
-| `vinext({ react: { compiler: true } })`          | ✅  | React Compiler auto memoization. Needs `@vitejs/plugin-react` 6.1+ and the optional `oxc-transform-react` package.                                                                                                     |
+| Feature                                          |     | Notes                                                                                                                                                                                                                                                    |
+| ------------------------------------------------ | --- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `next.config.js` / `.ts` / `.mjs`                | ✅  | Function configs, phase argument                                                                                                                                                                                                                         |
+| `rewrites` / `redirects` / `headers`             | ✅  | All phases, param interpolation. A source Next.js rejects fails config loading, as it fails the Next.js build: missing, not starting with `/`, over the 4,096-character built-regex limit, or rejected by path-to-regexp, such as a header glob `/api/*` |
+| Environment variables (`.env*`, `NEXT_PUBLIC_*`) | ✅  | Auto-loads Next.js-style dotenv files; only public vars are inlined                                                                                                                                                                                      |
+| `images` config                                  | 🟡  | Parsed but not used for optimization                                                                                                                                                                                                                     |
+| `experimental.optimizePackageImports`            | ✅  | Rewrites barrel imports to direct sub-module imports in RSC/SSR environments. A default set (lucide-react, date-fns, radix-ui, antd, MUI, and others) are always optimized. Add package names here to extend the list.                                   |
+| `vinext({ nextConfig })`                         | ✅  | Inline Next-style config from `vite.config.*`. Supports object-form and function-form config. When provided, this overrides root `next.config.*`.                                                                                                        |
+| `vinext({ react: { compiler: true } })`          | ✅  | React Compiler auto memoization. Needs `@vitejs/plugin-react` 6.1+ and the optional `oxc-transform-react` package.                                                                                                                                       |
+| `vinext({ disableNextLikeChunking: true })`      | ✅  | Loads each client component from its own chunk, instead of one chunk per route group (Next.js-like; App Router production builds). Grouping also turns off on its own when the client build has other chunk groups.                                      |
 
 ### React Compiler
 

package/dist/_virtual/_rolldown/runtime.js

@@ -6,7 +6,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod, mod.exports), cb = null), mod.exports);
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
 		key = keys[i];

package/dist/build/action-owner-manifest.d.ts

@@ -2,7 +2,7 @@ import { AppRoute } from "../routing/app-route-graph.js";
 import { Rollup } from "vite";
 import { RscPluginManager } from "@vitejs/plugin-rsc";
 //#region src/build/action-owner-manifest.d.ts
-type ActionOwnerRoute = Pick<AppRoute, "errorPath" | "errorPaths" | "forbiddenPath" | "forbiddenPaths" | "layoutErrorPaths" | "layouts" | "loadingPath" | "loadingPaths" | "notFoundPath" | "notFoundPaths" | "pagePath" | "parallelSlots" | "pattern" | "siblingIntercepts" | "templates" | "unauthorizedPath" | "unauthorizedPaths">;
+type ActionOwnerRoute = Pick<AppRoute, "errorPath" | "errorPaths" | "forbiddenPath" | "forbiddenPaths" | "layoutErrorPaths" | "layouts" | "loadingPath" | "loadingPaths" | "notFoundPath" | "notFoundPaths" | "pagePath" | "parallelSlots" | "pattern" | "segmentForbiddenPaths" | "segmentNotFoundPaths" | "segmentUnauthorizedPaths" | "siblingIntercepts" | "templates" | "unauthorizedPath" | "unauthorizedPaths">;
 export type ActionOwnerRouteReachability = Map<string, {
   clientReferenceImportIds: Set<string>;
   serverReferenceIds: Set<string>;
@@ -38,4 +38,5 @@ export declare function addClientActionReachability(options: {
   routeReachability: ActionOwnerRouteReachability;
 } & ActionOwnerReferenceMaps): void;
 export declare function buildActionOwnerManifest(routeReachability: ActionOwnerRouteReachability): Record<string, string[]>;
-//#endregion
+//#endregion
+export {};

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

@@ -15,6 +15,9 @@ function actionOwnerRouteEntryIds(route) {
 		...route.forbiddenPaths ?? [],
 		route.unauthorizedPath,
 		...route.unauthorizedPaths ?? [],
+		...route.segmentNotFoundPaths ?? [],
+		...route.segmentForbiddenPaths ?? [],
+		...route.segmentUnauthorizedPaths ?? [],
 		...route.parallelSlots.flatMap((slot) => [
 			slot.pagePath,
 			slot.defaultPath,
@@ -24,18 +27,31 @@ function actionOwnerRouteEntryIds(route) {
 			...slot.loadingPaths ?? [],
 			slot.errorPath,
 			slot.notFoundPath,
+			...slot.notFoundPaths ?? [],
 			...slot.interceptingRoutes.flatMap((intercept) => [
 				intercept.pagePath,
 				...intercept.layoutPaths,
 				...intercept.loadingPaths ?? [],
-				intercept.notFoundPath
+				intercept.notFoundPath,
+				intercept.forbiddenPath,
+				intercept.unauthorizedPath,
+				...intercept.notFoundPaths ?? [],
+				...intercept.forbiddenPaths ?? [],
+				...intercept.unauthorizedPaths ?? [],
+				...intercept.errorPaths ?? []
 			])
 		]),
 		...route.siblingIntercepts.flatMap((intercept) => [
 			intercept.pagePath,
 			...intercept.layoutPaths,
 			...intercept.loadingPaths ?? [],
-			intercept.notFoundPath
+			intercept.notFoundPath,
+			intercept.forbiddenPath,
+			intercept.unauthorizedPath,
+			...intercept.notFoundPaths ?? [],
+			...intercept.forbiddenPaths ?? [],
+			...intercept.unauthorizedPaths ?? [],
+			...intercept.errorPaths ?? []
 		])
 	].filter((value) => typeof value === "string");
 }

package/dist/build/app-page-static-eligibility.d.ts

@@ -12,4 +12,20 @@ import { AppRoute } from "../routing/app-route-graph.js";
  * unreadable route's fallback, so it never certifies one.
  */
 export declare function classifyAppPageRouteStaticEligibility(route: AppRoute, readMdxEsm: ((source: string) => string) | null): "eligible" | "ineligible" | "unreadable";
-//#endregion
+/**
+ * Whether the route's segment config rules out static generation, so Next.js
+ * renders it on every request. An "unreadable" route or a source that can't be
+ * read counts as not dynamic.
+ */
+export declare function isAppPageRouteRenderedDynamically(route: AppRoute, readMdxEsm: ((source: string) => string) | null): boolean;
+type AppRouteIntercept = AppRoute["siblingIntercepts"][number];
+/**
+ * Whether Next.js renders an intercepted page on every request. Next.js builds
+ * the intercepting page as its own route (`/feed/(.)photos/[id]`): the
+ * layouts of every folder from `app/` down to the intercepting page, then the
+ * page. `layoutPaths` are the candidate layouts; those outside the page's
+ * folder chain are ignored. An unreadable source counts as not dynamic.
+ */
+export declare function isAppInterceptRenderedDynamically(intercept: AppRouteIntercept, layoutPaths: readonly string[], readMdxEsm: ((source: string) => string) | null): boolean;
+//#endregion
+export {};

package/dist/build/app-page-static-eligibility.js

@@ -1,21 +1,15 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { extractExportConstNumber, extractExportConstString, hasRuntimeExportedName } from "./report.js";
 import { collectAppPageStaticGenerationRuntimes, hasAppPageGenerateStaticParamsAtLastDynamicSegment, isAppPageStaticEligible, isEdgeRuntime, resolveAppPageSegmentConfig, resolveAppPageStaticGenerationRuntime } from "../server/app-segment-config.js";
 import fs from "node:fs";
 //#region src/build/app-page-static-eligibility.ts
 /**
-* Whether Next.js classifies an App page route as static or SSG, read from its
-* layout, page and parallel-slot sources with the helpers dispatch applies to
-* the loaded modules. Only such a route has listed paths.
-*
-* An MDX source read without the MDX parser has unknown exports, so its route
-* is "unreadable". Its paths are still listed: the built runtime reads the real
-* exports and never stores a route that isn't static, while an unlisted path's
-* render failure would be dropped instead of failing. But no probe renders an
-* unreadable route's fallback, so it never certifies one.
+* Read the segment config exports of App layout and page sources. A source MDX
+* without the MDX parser leaves the reader "unreadable".
 */
-function classifyAppPageRouteStaticEligibility(route, readMdxEsm) {
+function createSegmentConfigReader(readMdxEsm) {
 	let unreadable = false;
-	const readSegmentConfig = (filePath) => {
+	const read = (filePath) => {
 		if (!filePath) return null;
 		let code = fs.readFileSync(filePath, "utf8");
 		if (filePath.toLowerCase().endsWith(".mdx")) {
@@ -36,6 +30,24 @@ function classifyAppPageRouteStaticEligibility(route, readMdxEsm) {
 			...runtime === null ? {} : { runtime }
 		};
 	};
+	return {
+		isUnreadable: () => unreadable,
+		read
+	};
+}
+/**
+* Whether Next.js classifies an App page route as static or SSG, read from its
+* layout, page and parallel-slot sources with the helpers dispatch applies to
+* the loaded modules. Only such a route has listed paths.
+*
+* An MDX source read without the MDX parser has unknown exports, so its route
+* is "unreadable". Its paths are still listed: the built runtime reads the real
+* exports and never stores a route that isn't static, while an unlisted path's
+* render failure would be dropped instead of failing. But no probe renders an
+* unreadable route's fallback, so it never certifies one.
+*/
+function classifyAppPageRouteStaticEligibility(route, readMdxEsm) {
+	const { isUnreadable, read: readSegmentConfig } = createSegmentConfigReader(readMdxEsm);
 	const layouts = route.layouts.map(readSegmentConfig);
 	const page = readSegmentConfig(route.pagePath);
 	const parallelBranches = route.parallelSlots.map((slot) => ({
@@ -48,7 +60,7 @@ function classifyAppPageRouteStaticEligibility(route, readMdxEsm) {
 		page: readSegmentConfig(slot.pagePath ?? slot.defaultPath),
 		routeSegments: slot.routeSegments
 	}));
-	if (unreadable) return "unreadable";
+	if (isUnreadable()) return "unreadable";
 	const segmentConfig = resolveAppPageSegmentConfig({
 		layouts,
 		layoutTreePositions: route.layoutTreePositions,
@@ -78,5 +90,60 @@ function classifyAppPageRouteStaticEligibility(route, readMdxEsm) {
 		revalidateSeconds: segmentConfig.revalidateSeconds
 	}) ? "eligible" : "ineligible";
 }
+/**
+* Whether the route's segment config rules out static generation, so Next.js
+* renders it on every request. An "unreadable" route or a source that can't be
+* read counts as not dynamic.
+*/
+function isAppPageRouteRenderedDynamically(route, readMdxEsm) {
+	try {
+		return classifyAppPageRouteStaticEligibility(route, readMdxEsm) === "ineligible";
+	} catch {
+		return false;
+	}
+}
+const INTERCEPTION_MARKER_RE = /^(?:\(\.\.\.\)|\(\.\.\)\(\.\.\)|\(\.\.\)|\(\.\))/;
+/**
+* Whether Next.js renders an intercepted page on every request. Next.js builds
+* the intercepting page as its own route (`/feed/(.)photos/[id]`): the
+* layouts of every folder from `app/` down to the intercepting page, then the
+* page. `layoutPaths` are the candidate layouts; those outside the page's
+* folder chain are ignored. An unreadable source counts as not dynamic.
+*/
+function isAppInterceptRenderedDynamically(intercept, layoutPaths, readMdxEsm) {
+	if (!intercept.sourcePageSegments) return false;
+	const routeSegments = intercept.sourcePageSegments.map((segment) => segment.replace(INTERCEPTION_MARKER_RE, ""));
+	try {
+		const pageDir = path.dirname(intercept.pagePath);
+		const layoutsByPosition = /* @__PURE__ */ new Map();
+		for (const layoutPath of layoutPaths) {
+			const relative = path.relative(path.dirname(layoutPath), pageDir);
+			if (relative.startsWith("..") || path.isAbsolute(relative)) continue;
+			const depthBelowLayout = relative.split("/").filter(Boolean).length;
+			layoutsByPosition.set(routeSegments.length - depthBelowLayout, layoutPath);
+		}
+		const layoutTreePositions = [...layoutsByPosition.keys()].sort((a, b) => a - b);
+		const { isUnreadable, read } = createSegmentConfigReader(readMdxEsm);
+		const layouts = layoutTreePositions.map((position) => read(layoutsByPosition.get(position)));
+		const page = read(intercept.pagePath);
+		if (isUnreadable()) return false;
+		const tree = {
+			layouts,
+			layoutTreePositions,
+			page,
+			routeSegments
+		};
+		const segmentConfig = resolveAppPageSegmentConfig(tree);
+		return !isAppPageStaticEligible({
+			dynamicConfig: segmentConfig.dynamicConfig,
+			hasGenerateStaticParams: hasAppPageGenerateStaticParamsAtLastDynamicSegment(tree),
+			isDynamicRoute: routeSegments.some((segment) => segment.startsWith("[") && segment.endsWith("]")),
+			isStaticGenerationEdgeRuntime: isEdgeRuntime(resolveAppPageStaticGenerationRuntime(collectAppPageStaticGenerationRuntimes(tree))),
+			revalidateSeconds: segmentConfig.revalidateSeconds
+		});
+	} catch {
+		return false;
+	}
+}
 //#endregion
-export { classifyAppPageRouteStaticEligibility };
+export { classifyAppPageRouteStaticEligibility, isAppInterceptRenderedDynamically, isAppPageRouteRenderedDynamically };

package/dist/build/clean-output.d.ts

@@ -9,4 +9,5 @@ type CleanBuildOutputResult = {
   outDir: string;
 };
 export declare function cleanBuildOutput(options: CleanBuildOutputOptions): CleanBuildOutputResult;
-//#endregion
+//#endregion
+export {};

package/dist/build/client-build-config.d.ts

@@ -13,15 +13,24 @@ type ClientAssetFileNameInfo = {
  * an asset (a single output asset can carry several `originalFileNames`).
  */
 export declare function createClientAssetFileNames(assetsDir: string): (assetInfo: ClientAssetFileNameInfo) => string;
+/**
+ * The App Router client build module that registers the client references
+ * whose modules are in the "vinext" chunk (see
+ * plugins/rsc-client-reference-loaders.ts). It joins that chunk, so it loads
+ * with the browser entry without adding to the entry's own chunk.
+ */
+export declare const RESOLVED_EAGER_CLIENT_REFERENCES_ID = "\0virtual:vinext-client-reference-eager";
 /**
  * Create a manualChunks function for client builds.
  *
  * Splits the client bundle into:
  * - "framework" — React, ReactDOM, and scheduler (loaded on every page)
  * - "vinext"    — shared vinext runtime shims
+ * - "vinext-app-router" — the App Router runtime, in Pages Router builds
  *
- * Route-owned client shims and all other vendor code are left to the bundler's
- * graph-based chunking so they stay behind their client-reference boundaries.
+ * Route-owned (App Router) or page-owned (Pages Router) client shims and all
+ * other vendor code are left to the bundler's graph-based chunking so they
+ * load only where they're used.
  *
  * Why not split every npm package into its own chunk?
  * - Per-package splitting (`vendor-X`) creates 50-200+ chunks for a
@@ -39,10 +48,62 @@ export declare function createClientAssetFileNames(assetsDir: string): (assetInf
  *   and route-specific code stays in route chunks.
  */
 export declare function createClientManualChunks(shimsDir: string, preserveRouteBoundaries?: boolean): (id: string) => string | undefined;
-export declare function createClientFileNameConfig(assetsDir: string): {
-  entryFileNames: string;
-  chunkFileNames: string;
+/**
+ * Web Worker output names. Workers are hash-only like client chunks, so their
+ * URLs don't publish source file names. Vite bundles each worker separately
+ * and stores the outputs by file name, so two workers' entries or chunks with
+ * identical code would share `[hash].js` and one's source map would overwrite
+ * the other's. Each name therefore also carries an opaque id derived from the
+ * chunk's module ids (root-relative for files).
+ */
+export declare function createWorkerFileNames(assetsDir: string, root: string): {
+  entryFileNames: (chunk: {
+    facadeModuleId: string | null;
+    moduleIds?: readonly string[];
+  }) => string;
+  chunkFileNames: (chunk: {
+    facadeModuleId: string | null;
+    moduleIds?: readonly string[];
+  }) => string;
 };
+/**
+ * vinext's client output file names, limited to the ones the incoming client
+ * environment config leaves unset. Vite merges `config` hook results over the
+ * user's config, so vinext applies these from `configEnvironment` instead: by
+ * then the user's top-level `build` and `environments.client.build` are merged
+ * into the client environment, and a user-provided pattern wins.
+ *
+ * Returns null for array-shaped output, which cannot be augmented without Vite
+ * concatenating a second output entry. Array-shaped client output is advanced
+ * config vinext doesn't support: Vite also appends vinext's own client output
+ * object (code splitting) to the user's array, producing an extra bundle.
+ */
+export declare function createClientOutputFileNameDefaults(output: VinextBuildBundlerOptions["output"], assetsDir: string): {
+  entryFileNames?: string | undefined;
+  chunkFileNames?: string | undefined;
+  assetFileNames?: ((assetInfo: ClientAssetFileNameInfo) => string) | undefined;
+} | null;
+/** Entry, chunk and asset file names from a (non-array) bundler output config. */
+export declare function getOutputFileNames(output: VinextBuildBundlerOptions["output"]): Pick<VinextBuildOutput, "entryFileNames" | "chunkFileNames" | "assetFileNames">;
+/**
+ * User-provided client file name patterns vinext cannot serve correctly:
+ * - outside `assetsDir`: built-asset URLs, immutable caching and
+ *   precompression all assume client output lives there;
+ * - without `[hash]`: everything under `assetsDir` is served
+ *   `immutable`, so an unhashed URL would pin stale code for a year;
+ * - JS not ending in `.js`: client metadata and Pages Router script
+ *   tags only recognize `.js` chunks;
+ * - assets not ending in `[extname]` (or `.[ext]`): CSS without its real
+ *   extension is served as `application/octet-stream` and rejected by browsers.
+ * - asset basenames not starting with `[name].` or `[name]-`: restoring CSS
+ *   `url()` assets deduplicated across builds swaps the source stem at the
+ *   start of the emitted basename (see css-url-assets.ts), so any other
+ *   placement or delimiter drops the hash from the restored sibling.
+ * This is a guard against common mistakes, not full validation: function
+ * patterns and array-shaped output are advanced config left to the user to
+ * keep within these rules.
+ */
+export declare function findUnsupportedClientOutputFileNames(output: VinextBuildBundlerOptions["output"], assetsDir: string): string[];
 export declare function createClientCodeSplittingConfig(clientManualChunks: (id: string) => string | undefined): {
   minSize: number;
   groups: {
@@ -126,4 +187,14 @@ export declare function assertClientOutDirIsSeparate(root: string, dirs: {
   rscOutDir?: string;
   ssrOutDir?: string;
 }): void;
-//#endregion
+/**
+ * Whether client output options have chunk groups (`codeSplitting.groups`,
+ * `advancedChunks.groups` or `manualChunks`) other than vinext's own
+ * `ownGroups`, whether they came from the user or another plugin. vinext's
+ * client-reference route grouping is disabled in that case: a manual group can
+ * move modules out of a route group's chunk, and that combination has been
+ * seen to evaluate modules out of order and break hydration.
+ */
+export declare function hasUserClientChunkGroups(output: unknown, ownGroups: ReadonlySet<unknown>): boolean;
+//#endregion
+export {};

package/dist/build/client-build-config.js

@@ -1,4 +1,7 @@
 import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { stripViteModuleQuery } from "../utils/path.js";
+import { WORKER_IMAGE_METADATA_PREFIX } from "../plugins/worker-image-imports.js";
+import { createHash } from "node:crypto";
 //#region src/build/client-build-config.ts
 const ROUTE_OWNED_CLIENT_SHIMS = /* @__PURE__ */ new Set([
 	"app-router-tree-context",
@@ -7,6 +10,8 @@ const ROUTE_OWNED_CLIENT_SHIMS = /* @__PURE__ */ new Set([
 	"dynamic-preload-chunks",
 	"form",
 	"image",
+	"image-config",
+	"image-props",
 	"internal/hybrid-client-route-owner",
 	"layout-segment-context",
 	"legacy-image",
@@ -16,7 +21,32 @@ const ROUTE_OWNED_CLIENT_SHIMS = /* @__PURE__ */ new Set([
 	"script",
 	"web-vitals"
 ]);
-const NEXT_CLIENT_CSS_ASSET_FILE_NAMES = "css/[name].[hash:8][extname]";
+const PAGE_OWNED_CLIENT_SHIMS = /* @__PURE__ */ new Set([
+	"dynamic",
+	"dynamic-preload-chunks",
+	"form",
+	"image",
+	"image-config",
+	"image-props",
+	"legacy-image",
+	"offline",
+	"script",
+	"web-vitals",
+	"error"
+]);
+const PAGES_APP_ROUTER_RUNTIME_SHIMS = /* @__PURE__ */ new Set([
+	"app-router-scroll-state",
+	"internal/app-prefetch-rsc-request",
+	"internal/navigation-untracked",
+	"internal/pages-router-accessor",
+	"navigation",
+	"navigation-context-state",
+	"navigation-errors",
+	"ppr-fallback-shell",
+	"readonly-url-search-params",
+	"unrecognized-action-error"
+]);
+const NEXT_CLIENT_CSS_ASSET_FILE_NAMES = "css/[hash][extname]";
 const NEXT_CLIENT_STATIC_MEDIA_FILE_NAMES = "media/[name].[hash:8][extname]";
 function joinAssetFileNamePattern(assetsDir, pattern) {
 	let end = assetsDir.length;
@@ -61,14 +91,23 @@ function getPackageName(id) {
 	return rest.split("/")[0] || null;
 }
 /**
+* The App Router client build module that registers the client references
+* whose modules are in the "vinext" chunk (see
+* plugins/rsc-client-reference-loaders.ts). It joins that chunk, so it loads
+* with the browser entry without adding to the entry's own chunk.
+*/
+const RESOLVED_EAGER_CLIENT_REFERENCES_ID = "\0virtual:vinext-client-reference-eager";
+/**
 * Create a manualChunks function for client builds.
 *
 * Splits the client bundle into:
 * - "framework" — React, ReactDOM, and scheduler (loaded on every page)
 * - "vinext"    — shared vinext runtime shims
+* - "vinext-app-router" — the App Router runtime, in Pages Router builds
 *
-* Route-owned client shims and all other vendor code are left to the bundler's
-* graph-based chunking so they stay behind their client-reference boundaries.
+* Route-owned (App Router) or page-owned (Pages Router) client shims and all
+* other vendor code are left to the bundler's graph-based chunking so they
+* load only where they're used.
 *
 * Why not split every npm package into its own chunk?
 * - Per-package splitting (`vendor-X`) creates 50-200+ chunks for a
@@ -86,17 +125,19 @@ function getPackageName(id) {
 *   and route-specific code stays in route chunks.
 */
 function createClientManualChunks(shimsDir, preserveRouteBoundaries = false) {
+	const instrumentationStatePrefix = path.join(shimsDir, "../client/instrumentation-client-state.");
 	return function clientManualChunks(id) {
+		if (id === "\0virtual:vinext-client-reference-eager") return "vinext";
 		const slashedId = toSlash(id);
 		if (slashedId.startsWith(shimsDir)) {
-			if (preserveRouteBoundaries) {
-				const relativeId = slashedId.slice(shimsDir.length).split("?", 1)[0] ?? "";
-				const extensionIndex = relativeId.lastIndexOf(".");
-				const shimName = extensionIndex === -1 ? relativeId : relativeId.slice(0, extensionIndex);
-				if (ROUTE_OWNED_CLIENT_SHIMS.has(shimName)) return void 0;
-			}
+			const relativeId = slashedId.slice(shimsDir.length).split("?", 1)[0] ?? "";
+			const extensionIndex = relativeId.lastIndexOf(".");
+			const shimName = extensionIndex === -1 ? relativeId : relativeId.slice(0, extensionIndex);
+			if ((preserveRouteBoundaries ? ROUTE_OWNED_CLIENT_SHIMS : PAGE_OWNED_CLIENT_SHIMS).has(shimName)) return void 0;
+			if (!preserveRouteBoundaries && PAGES_APP_ROUTER_RUNTIME_SHIMS.has(shimName)) return "vinext-app-router";
 			return "vinext";
 		}
+		if (slashedId.startsWith(instrumentationStatePrefix)) return "vinext";
 		if (id.includes("node_modules")) {
 			const pkg = getPackageName(id);
 			if (!pkg) return void 0;
@@ -110,13 +151,119 @@ function createClientManualChunks(shimsDir, preserveRouteBoundaries = false) {
 		}
 	};
 }
+/**
+* Client JS is emitted as hash-only `<assetsDir>/chunks/[hash].js`. Rolldown
+* names a chunk after its first module, so `[name]` would publish component
+* and source file names in public asset URLs. Next.js doesn't put component
+* names in production chunk URLs either: webpack names split chunks by
+* deterministic numeric id. Users can opt back into `[name]` through their own
+* Vite config; see createClientOutputFileNameDefaults.
+*/
 function createClientFileNameConfig(assetsDir) {
 	const chunksDir = `${assetsDir}/chunks`;
 	return {
-		entryFileNames: `${chunksDir}/[name]-[hash].js`,
-		chunkFileNames: `${chunksDir}/[name]-[hash].js`
+		entryFileNames: `${chunksDir}/[hash].js`,
+		chunkFileNames: `${chunksDir}/[hash].js`
 	};
 }
+/**
+* Web Worker output names. Workers are hash-only like client chunks, so their
+* URLs don't publish source file names. Vite bundles each worker separately
+* and stores the outputs by file name, so two workers' entries or chunks with
+* identical code would share `[hash].js` and one's source map would overwrite
+* the other's. Each name therefore also carries an opaque id derived from the
+* chunk's module ids (root-relative for files).
+*/
+function createWorkerFileNames(assetsDir, root) {
+	const workersDir = `${assetsDir}/workers`;
+	const fileName = (chunk) => {
+		const ids = chunk.facadeModuleId ? [chunk.facadeModuleId] : chunk.moduleIds ?? [];
+		const chunkId = JSON.stringify(ids.map((id) => {
+			const file = stripViteModuleQuery(id);
+			if (path.isAbsolute(file)) return ["file", toSlash(path.relative(root, file)) + id.slice(file.length)];
+			const imagePath = id.startsWith("\0vinext-worker-image-meta:") ? id.slice(WORKER_IMAGE_METADATA_PREFIX.length) : void 0;
+			if (imagePath !== void 0 && path.isAbsolute(imagePath)) return ["image-meta", toSlash(path.relative(root, imagePath))];
+			return ["id", id];
+		}));
+		const idHash = createHash("sha256").update(chunkId).digest("hex").slice(0, 8);
+		return `${workersDir}/${idHash}-[hash].js`;
+	};
+	return {
+		entryFileNames: fileName,
+		chunkFileNames: fileName
+	};
+}
+/**
+* vinext's client output file names, limited to the ones the incoming client
+* environment config leaves unset. Vite merges `config` hook results over the
+* user's config, so vinext applies these from `configEnvironment` instead: by
+* then the user's top-level `build` and `environments.client.build` are merged
+* into the client environment, and a user-provided pattern wins.
+*
+* Returns null for array-shaped output, which cannot be augmented without Vite
+* concatenating a second output entry. Array-shaped client output is advanced
+* config vinext doesn't support: Vite also appends vinext's own client output
+* object (code splitting) to the user's array, producing an extra bundle.
+*/
+function createClientOutputFileNameDefaults(output, assetsDir) {
+	if (Array.isArray(output)) return null;
+	const configured = output ?? {};
+	const { entryFileNames, chunkFileNames } = createClientFileNameConfig(assetsDir);
+	return {
+		...configured.entryFileNames === void 0 ? { entryFileNames } : {},
+		...configured.chunkFileNames === void 0 ? { chunkFileNames } : {},
+		...configured.assetFileNames === void 0 ? { assetFileNames: createClientAssetFileNames(assetsDir) } : {}
+	};
+}
+/** Entry, chunk and asset file names from a (non-array) bundler output config. */
+function getOutputFileNames(output) {
+	if (!output || Array.isArray(output)) return {};
+	const { entryFileNames, chunkFileNames, assetFileNames } = output;
+	return {
+		entryFileNames,
+		chunkFileNames,
+		assetFileNames
+	};
+}
+/**
+* User-provided client file name patterns vinext cannot serve correctly:
+* - outside `assetsDir`: built-asset URLs, immutable caching and
+*   precompression all assume client output lives there;
+* - without `[hash]`: everything under `assetsDir` is served
+*   `immutable`, so an unhashed URL would pin stale code for a year;
+* - JS not ending in `.js`: client metadata and Pages Router script
+*   tags only recognize `.js` chunks;
+* - assets not ending in `[extname]` (or `.[ext]`): CSS without its real
+*   extension is served as `application/octet-stream` and rejected by browsers.
+* - asset basenames not starting with `[name].` or `[name]-`: restoring CSS
+*   `url()` assets deduplicated across builds swaps the source stem at the
+*   start of the emitted basename (see css-url-assets.ts), so any other
+*   placement or delimiter drops the hash from the restored sibling.
+* This is a guard against common mistakes, not full validation: function
+* patterns and array-shaped output are advanced config left to the user to
+* keep within these rules.
+*/
+function findUnsupportedClientOutputFileNames(output, assetsDir) {
+	if (!output || Array.isArray(output)) return [];
+	const unsupported = [];
+	for (const key of [
+		"entryFileNames",
+		"chunkFileNames",
+		"assetFileNames"
+	]) {
+		const value = output[key];
+		if (typeof value !== "string") continue;
+		const problems = [
+			!value.startsWith(`${assetsDir}/`) && `outside "${assetsDir}/"`,
+			!value.includes("[hash") && "no [hash]",
+			key !== "assetFileNames" && !value.endsWith(".js") && "not \".js\"",
+			key === "assetFileNames" && !value.endsWith("[extname]") && !value.endsWith(".[ext]") && "not ending in [extname]",
+			key === "assetFileNames" && !/^\[name\][.-]/.test(value.slice(value.lastIndexOf("/") + 1)) && "basename not starting with \"[name].\" or \"[name]-\""
+		].filter(Boolean);
+		if (problems.length > 0) unsupported.push(`${key}: ${JSON.stringify(value)} (${problems.join(", ")})`);
+	}
+	return unsupported;
+}
 function createClientCodeSplittingConfig(clientManualChunks) {
 	return {
 		minSize: 1e4,
@@ -282,5 +429,22 @@ function assertClientOutDirIsSeparate(root, dirs) {
 		throw new Error(`[vinext] clientOutDir "${dirs.clientOutDir}" contains ${name} "${dir}". The client build runs last and empties its output directory, which would delete the server build. Use separate output directories.`);
 	}
 }
+function hasChunkGroups(output, ownGroups) {
+	if (!output || typeof output !== "object") return false;
+	const { advancedChunks, codeSplitting, manualChunks } = output;
+	if (manualChunks !== void 0) return true;
+	return [...advancedChunks?.groups ?? [], ...(codeSplitting && typeof codeSplitting === "object" ? codeSplitting.groups : void 0) ?? []].some((group) => !ownGroups.has(group));
+}
+/**
+* Whether client output options have chunk groups (`codeSplitting.groups`,
+* `advancedChunks.groups` or `manualChunks`) other than vinext's own
+* `ownGroups`, whether they came from the user or another plugin. vinext's
+* client-reference route grouping is disabled in that case: a manual group can
+* move modules out of a route group's chunk, and that combination has been
+* seen to evaluate modules out of order and break hydration.
+*/
+function hasUserClientChunkGroups(output, ownGroups) {
+	return Array.isArray(output) ? output.some((entry) => hasChunkGroups(entry, ownGroups)) : hasChunkGroups(output, ownGroups);
+}
 //#endregion
-export { RSC_FRAMEWORK_CHUNK_TEST, assertClientOutDirIsSeparate, createClientAssetFileNames, createClientCodeSplittingConfig, createClientFileNameConfig, createClientManualChunks, createMultiStageChunkFileNames, createMultiStageCodeSplittingConfig, createRscFrameworkChunkOutputConfig, getBuildBundlerOptions, getClientTreeshakeConfig, isRscFrameworkModule, sanitizeRscChunkFileName, withBuildBundlerOptions };
+export { RESOLVED_EAGER_CLIENT_REFERENCES_ID, RSC_FRAMEWORK_CHUNK_TEST, assertClientOutDirIsSeparate, createClientAssetFileNames, createClientCodeSplittingConfig, createClientManualChunks, createClientOutputFileNameDefaults, createMultiStageChunkFileNames, createMultiStageCodeSplittingConfig, createRscFrameworkChunkOutputConfig, createWorkerFileNames, findUnsupportedClientOutputFileNames, getBuildBundlerOptions, getClientTreeshakeConfig, getOutputFileNames, hasUserClientChunkGroups, isRscFrameworkModule, sanitizeRscChunkFileName, withBuildBundlerOptions };