vinext 1.3.0 → 1.4.0

package/dist/build/client-reference-chunks.js

@@ -0,0 +1,111 @@
+import "../plugins/rsc-client-reference-loaders.js";
+import { toManifestModuleId } from "../plugins/dynamic-preload-metadata.js";
+//#region src/build/client-reference-chunks.ts
+/** As Vite's preload helper tells a stylesheet: by its URL's path. */
+function isStylesheet(file) {
+	return new URL(file, "http://vinext.local/").pathname.endsWith(".css");
+}
+/**
+* Collect what each App Router client reference loads in the browser from the
+* client bundle: the chunk holding the module that registers it (see
+* plugins/rsc-client-reference-loaders.ts), and the JS chunks and stylesheets
+* that chunk needs, as Vite's preload helper would load them for a dynamic
+* import. JS chunks the App browser entry imports statically have loaded
+* before any Flight row decodes, so they are left out.
+*
+* @param moduleKeys Client reference modules by resolved id, with the keys of
+*   the references each registers.
+* @param modulePreload The client build's `build.modulePreload`, which picks
+*   the JS chunks to modulepreload, as it does for Vite's preload helper. Its
+*   `resolveDependencies` sees the chunk that dynamically imports each
+*   registering module as the host, as Vite passes it.
+*/
+function collectClientReferenceChunks(bundle, moduleKeys, appBrowserEntry, modulePreload) {
+	const chunks = /* @__PURE__ */ new Map();
+	let host;
+	for (const output of Object.values(bundle)) {
+		if (output.type !== "chunk") continue;
+		chunks.set(output.fileName, output);
+		if (output.facadeModuleId === "\0virtual:vinext-client-reference-chunks") host = output;
+	}
+	const staticImports = (chunk) => {
+		const seen = /* @__PURE__ */ new Set([chunk.fileName]);
+		const order = [chunk];
+		for (let i = 0; i < order.length; i++) for (const file of order[i].imports) {
+			const imported = chunks.get(file);
+			if (!imported || seen.has(file)) continue;
+			seen.add(file);
+			order.push(imported);
+		}
+		return order;
+	};
+	const eager = new Set(appBrowserEntry ? staticImports(appBrowserEntry).map((chunk) => chunk.fileName) : []);
+	const result = {
+		references: {},
+		modules: []
+	};
+	for (const chunk of chunks.values()) {
+		const keys = chunk.moduleIds.flatMap((moduleId) => moduleKeys.get(moduleId) ?? []);
+		if (keys.length === 0) continue;
+		const imports = [];
+		const css = /* @__PURE__ */ new Set();
+		const visited = /* @__PURE__ */ new Set();
+		const addDeps = (loaded) => {
+			if (visited.has(loaded.fileName)) return;
+			visited.add(loaded.fileName);
+			if (loaded !== chunk) imports.push(loaded.fileName);
+			for (const file of loaded.imports) {
+				const imported = chunks.get(file);
+				if (imported) addDeps(imported);
+			}
+			for (const file of loaded.viteMetadata?.importedCss ?? []) css.add(file);
+		};
+		addDeps(chunk);
+		let preloads = imports.length + css.size > 0 ? [chunk.fileName, ...imports] : [];
+		let stylesheets = [...css];
+		if (modulePreload === false) preloads = [];
+		else if (modulePreload?.resolveDependencies && host) {
+			const resolved = modulePreload.resolveDependencies(chunk.fileName, preloads, {
+				hostId: host.fileName,
+				hostType: "js"
+			});
+			preloads = resolved.filter((file) => !isStylesheet(file));
+			stylesheets = [.../* @__PURE__ */ new Set([...resolved.filter(isStylesheet), ...css])];
+		}
+		preloads = [...new Set(preloads)].filter((file) => !eager.has(file) && (file !== chunk.fileName || stylesheets.length > 0));
+		const index = result.modules.push({
+			file: chunk.fileName,
+			imports: preloads,
+			css: stylesheets
+		}) - 1;
+		for (const key of keys) result.references[key] = index;
+	}
+	return result.modules.length > 0 ? result : void 0;
+}
+/**
+* Vite's build manifest keys a dynamic import by the module it imports, and
+* next/dynamic's SSR preloads look up the module a boundary imports (see
+* shims/dynamic-preload-chunks.tsx). The client build imports a client
+* reference outside every group through the module that registers it, not
+* the reference's own module, so map the reference's module to the chunk of
+* the module that registers it, keyed as Vite keys a manifest entry.
+*
+* @param getImportedIds A module's static imports, as the bundler resolved
+*   them.
+*/
+function collectClientReferenceSources(bundle, getImportedIds, root) {
+	const sources = {};
+	for (const output of Object.values(bundle)) {
+		if (output.type !== "chunk") continue;
+		for (const moduleId of output.moduleIds) {
+			if (!moduleId.startsWith("\0virtual:vinext-client-reference-module/")) continue;
+			const source = getImportedIds(moduleId)?.at(-1);
+			if (source === void 0 || source.startsWith("\0")) continue;
+			const key = toManifestModuleId(root, source);
+			if (key) sources[key] = output.fileName;
+		}
+	}
+	return Object.keys(sources).length > 0 ? sources : void 0;
+}
+//#endregion
+export { collectClientReferenceChunks, collectClientReferenceSources };

package/dist/build/client-reference-groups.d.ts

@@ -49,6 +49,13 @@ export type ClientReferencePreloadPlan = {
   routes: Map<string, number[]>;
   /** The files of a render without a route, as indices into `files`. */
   routeless: number[];
+  /**
+   * References route files reach only through static imports, outside
+   * `always`. A render may stream one whose module evaluates asynchronously
+   * instead of waiting for it; a reference any dynamic import reaches, such as
+   * a `next/dynamic` component, always loads first.
+   */
+  staticOnly: string[];
 };
 /**
  * Plan which client references SSR loads before rendering each route. A route
@@ -160,4 +167,5 @@ export declare function planClientReferenceGroups(options: {
   costs: ReadonlyMap<string, number | null>;
   maxCostBytes: number;
 }): ClientReferenceGroup[];
-//#endregion
+//#endregion
+export {};

package/dist/build/client-reference-groups.js

@@ -46,7 +46,13 @@ function interceptEntryIds(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");
 }
 /**
@@ -221,11 +227,43 @@ function collectClientReferencePreloadPlan(options) {
 	const stopAt = /* @__PURE__ */ new Set([...fileIndices.keys(), ...[...interceptFiles, ...alwaysRoots].map(canonicalize)]);
 	const always = /* @__PURE__ */ new Set([...referencesReachedFrom(options.entryIds, stopAt), ...referencesReachedFrom(alwaysRoots)]);
 	for (const id of options.clientReferenceIds) if (!reached.has(id)) always.add(id);
+	const dynamicallyReached = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const pending = [...options.entryIds.map(canonicalize), ...stopAt].map((id) => [
+		id,
+		false,
+		true
+	]);
+	while (pending.length > 0) {
+		const [id, dynamic, root] = pending.pop();
+		if (!root && stopAt.has(id)) continue;
+		const key = dynamic ? `dynamic:${id}` : id;
+		if (visited.has(key)) continue;
+		visited.add(key);
+		if (options.clientReferenceIds.has(id)) {
+			if (dynamic) dynamicallyReached.add(id);
+			continue;
+		}
+		const info = getModuleInfo(id);
+		if (!info) continue;
+		for (const imported of info.importedIds) pending.push([
+			imported,
+			dynamic,
+			false
+		]);
+		for (const imported of info.dynamicallyImportedIds) pending.push([
+			imported,
+			true,
+			false
+		]);
+	}
+	const staticOnly = [...new Set(files.flat())].filter((id) => !always.has(id) && !dynamicallyReached.has(id));
 	return {
 		always: [...always],
 		files,
 		routes,
-		routeless
+		routeless,
+		staticOnly
 	};
 }
 function importedName(kind, name) {

package/dist/build/css-url-assets.d.ts

@@ -26,4 +26,5 @@ export declare function rebaseCssUrlAssetReferences(code: string, sourceDirector
  * code only has the leaked marker stripped — no sibling files are emitted.
  */
 export declare function restoreDedupedCssAssetReferences(bundle: CssUrlAssetBundle, emitRestoredAsset: EmitRestoredCssUrlAsset): void;
-//#endregion
+//#endregion
+export {};

package/dist/build/google-fonts/fallback-metrics.d.ts

@@ -8,4 +8,5 @@ type AdjustFontFallback = {
 };
 export declare function getFallbackFontOverrideMetrics(fontFamily: string): AdjustFontFallback | undefined;
 export declare function buildFallbackFontFace(family: string, metrics: AdjustFontFallback): string;
-//#endregion
+//#endregion
+export {};

package/dist/build/google-fonts/find-font-files-in-css.d.ts

@@ -11,5 +11,6 @@
 export declare function findFontFilesInCss(css: string, subsetsToPreload?: string[]): {
   googleFontFileUrl: string;
   preloadFontFile: boolean;
+  ext: string;
 }[];
 //#endregion

package/dist/build/google-fonts/find-font-files-in-css.js

@@ -1,4 +1,11 @@
 //#region src/build/google-fonts/find-font-files-in-css.ts
+const formatToExtension = /* @__PURE__ */ new Map([
+	["woff", "woff"],
+	["woff2", "woff2"],
+	["truetype", "ttf"],
+	["opentype", "otf"],
+	["embedded-opentype", "eot"]
+]);
 /**
 * Find all font files in the CSS response and determine which files should be preloaded.
 * In Google Fonts responses, the @font-face's subset is above it in a comment.
@@ -16,10 +23,16 @@ function findFontFilesInCss(css, subsetsToPreload) {
 		if (newSubset) currentSubset = newSubset;
 		else {
 			const googleFontFileUrl = /src: url\((.+?)\)/.exec(line)?.[1];
-			if (googleFontFileUrl && !fontFiles.some((foundFile) => foundFile.googleFontFileUrl === googleFontFileUrl)) fontFiles.push({
-				googleFontFileUrl,
-				preloadFontFile: !!subsetsToPreload?.includes(currentSubset)
-			});
+			if (googleFontFileUrl && !fontFiles.some((foundFile) => foundFile.googleFontFileUrl === googleFontFileUrl)) {
+				const pathname = googleFontFileUrl.split(/[?#]/, 1)[0];
+				const format = /format\(['"](.+?)['"]\)/.exec(line)?.[1];
+				const ext = /\.(woff|woff2|eot|ttf|otf)$/.exec(pathname)?.[1] ?? formatToExtension.get(format ?? "") ?? "woff2";
+				fontFiles.push({
+					googleFontFileUrl,
+					preloadFontFile: !!subsetsToPreload?.includes(currentSubset),
+					ext
+				});
+			}
 		}
 	}
 	return fontFiles;

package/dist/build/google-fonts/font-metadata.d.ts

@@ -16,4 +16,5 @@ type FontFamilyMetadata = {
   subsets: string[];
 };
 export declare const googleFontsMetadata: Record<string, FontFamilyMetadata>;
-//#endregion
+//#endregion
+export {};

package/dist/build/google-fonts/validate.d.ts

@@ -23,4 +23,5 @@ type ValidatedGoogleFontOptions = {
   subsets: string[];
 };
 export declare function validateGoogleFontOptions(fontFamily: string, options: GoogleFontOptions): ValidatedGoogleFontOptions;
-//#endregion
+//#endregion
+export {};

package/dist/build/inline-css.d.ts

@@ -2,4 +2,5 @@
 type InlineCssManifest = Record<string, string>;
 export declare function collectInlineCssManifest(clientDir: string, assetPrefix: string): InlineCssManifest;
 export declare function injectInlineCssManifestGlobal(entryPath: string, manifest: InlineCssManifest): boolean;
-//#endregion
+//#endregion
+export {};

package/dist/build/module-dependency-cache.d.ts

@@ -31,4 +31,5 @@ export declare class ModuleDependencyStore<T> {
   invalidate(files: readonly string[], event: FileEvent["event"]): boolean;
   clear(): void;
 }
-//#endregion
+//#endregion
+export {};

package/dist/build/next-client-runtime-manifests.d.ts

@@ -18,4 +18,5 @@ export declare function getPagesManifestPage(pagesDir: string, filePath: string,
 export declare function buildNextClientBuildManifestContent(rewrites: ResolvedNextConfig["rewrites"], pages: readonly string[]): string;
 export declare function buildNextClientSsgManifestContent(): string;
 export declare function emitNextClientRuntimeManifests(options: EmitNextClientRuntimeManifestsOptions): void;
-//#endregion
+//#endregion
+export {};

package/dist/build/precompress.d.ts

@@ -28,4 +28,5 @@ export declare function precompressAssets(clientDir: string, options?: {
   assetsDir?: string;
   onProgress?: (completed: number, total: number, file: string) => void;
 }): Promise<PrecompressResult>;
-//#endregion
+//#endregion
+export {};

package/dist/build/precompress.js

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

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

@@ -94,4 +94,5 @@ type PrerenderPathDiscoveryOptions = {
 export declare function matchesMiddlewareWarmPath(pathname: string, matcher: MatcherConfig | undefined, i18n: ResolvedNextConfig["i18n"]): boolean;
 export declare function discoverPrerenderPathManifest(options: PrerenderPathDiscoveryOptions): Promise<PrerenderPathManifest | null>;
 export declare function emitPrerenderPathManifest(options: PrerenderPathDiscoveryOptions): Promise<PrerenderPathManifest | null>;
-//#endregion
+//#endregion
+export {};

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

@@ -11,4 +11,5 @@ type PrerenderPhaseEnv = {
  * overwriting the caller's prior phase when they finish.
  */
 export declare function enterPrerenderPhase(env?: PrerenderPhaseEnv): () => void;
-//#endregion
+//#endregion
+export {};

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

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

package/dist/build/prerender.d.ts

@@ -171,8 +171,9 @@ type PrerenderAppOptionsInternal = PrerenderAppOptions & {
  * Throws on partial or malformed embeds (chunks present but no done marker,
  * tampered chunk JSON, etc.) — those are real vinext-internal regressions.
  *
- * Safe regex usage: safeJsonStringify (used by createRscEmbedTransform) escapes
- * all '<' and '>' in the embedded JSON, preventing false </script> matches.
+ * Safe regex usage: scriptSafeJsonStringify (used by createRscEmbedTransform)
+ * escapes every '<' that begins "</script" (case-insensitive) in the embedded
+ * JSON, preventing false </script> matches.
  */
 export declare function extractRscPayloadFromPrerenderedHtml(html: string): Uint8Array | null;
 /**

package/dist/build/prerender.js

@@ -12,16 +12,16 @@ import { NoOpCacheHandler, getCacheHandler, setCacheHandler } from "../shims/cac
 import { headersContextFromRequest, runWithHeadersContext } from "../shims/headers.js";
 import { _consumeRequestScopedCacheLife } from "../shims/cache-request-state.js";
 import { normalizeStaticPathsEntry } from "../routing/route-pattern.js";
-import { createRscRequestUrl } from "../server/app-rsc-cache-busting.js";
 import { readPrerenderSecret } from "./server-manifest.js";
 import { buildPregeneratedConcretePathTable } from "../server/prerender-manifest.js";
 import { concatUint8Arrays, decodeRscEmbeddedChunk } from "../server/app-rsc-embedded-chunks.js";
+import { createRscRequestUrl } from "../server/app-rsc-cache-busting.js";
 import { navigationRuntimeRscBootstrapExpression } from "../server/app-ssr-stream.js";
 import { encodePrerenderRouteParams, serializePrerenderRouteParamsHeader } from "../server/prerender-route-params.js";
-import { createAppPprFallbackShells, markAppPprDynamicFallbackShellHtml } from "../server/app-ppr-fallback-shell.js";
-import { getAppRouteOutputPath, getOutputPath, getRscOutputPath } from "../utils/prerender-output-paths.js";
 import { startProdServer } from "../server/prod-server.js";
 import { prerenderPoolAvailable, resolvePrerenderPoolSize, startPrerenderServerPool } from "./prerender-server-pool.js";
+import { getAppRouteOutputPath, getOutputPath, getRscOutputPath } from "../utils/prerender-output-paths.js";
+import { createAppPprFallbackShells, markAppPprDynamicFallbackShellHtml } from "../server/app-ppr-fallback-shell.js";
 import { enterPrerenderPhase } from "./prerender-phase.js";
 import { buildAppRouteCacheValue } from "../server/app-route-handler-response.js";
 import fs from "node:fs";
@@ -92,8 +92,9 @@ const RSC_RUNTIME_DONE_SCRIPT = `${RSC_RUNTIME_BOOTSTRAP_EXPRESSION}.done=true`;
 * Throws on partial or malformed embeds (chunks present but no done marker,
 * tampered chunk JSON, etc.) — those are real vinext-internal regressions.
 *
-* Safe regex usage: safeJsonStringify (used by createRscEmbedTransform) escapes
-* all '<' and '>' in the embedded JSON, preventing false <\/script> matches.
+* Safe regex usage: scriptSafeJsonStringify (used by createRscEmbedTransform)
+* escapes every '<' that begins "<\/script" (case-insensitive) in the embedded
+* JSON, preventing false <\/script> matches.
 */
 function extractRscPayloadFromPrerenderedHtml(html) {
 	const scriptPattern = /<script(?:\s[^>]*)?>([\s\S]*?)<\/script>/gi;

package/dist/build/report.d.ts

@@ -1,5 +1,4 @@
 import { AppRoute } from "../routing/app-route-graph.js";
-import { LayoutBuildClassification } from "./layout-classification-types.js";
 import { Route } from "../routing/pages-router.js";
 import { PrerenderResult } from "./prerender.js";
 //#region src/build/report.d.ts
@@ -77,19 +76,6 @@ export declare function extractExportConstNumber(code: string, name: string): nu
  *   null     — no `revalidate` key found (fully static)
  */
 export declare function extractGetStaticPropsRevalidate(code: string): number | false | null;
-/**
- * Classifies a layout file by its segment config exports (`dynamic`, `revalidate`).
- *
- * Returns a tagged `LayoutBuildClassification` carrying both the decision and
- * the specific segment-config field that produced it. `{ kind: "absent" }`
- * means no segment config is present and the caller should defer to the next
- * layer (module graph analysis).
- *
- * Unlike page classification, positive `revalidate` values are not meaningful
- * for layout skip decisions — ISR is a page-level concept. Only the extremes
- * (`revalidate = 0` → dynamic, `revalidate = Infinity` → static) are decisive.
- */
-export declare function classifyLayoutSegmentConfig(code: string): LayoutBuildClassification;
 /**
  * Classifies a Pages Router page file by reading its source and examining
  * which data-fetching exports it contains.
@@ -163,4 +149,5 @@ export declare function printBuildReport(options: {
   pageExtensions: string[];
   prerenderResult?: PrerenderResult;
 }): Promise<void>;
-//#endregion
+//#endregion
+export {};

package/dist/build/report.js

@@ -392,56 +392,6 @@ function propertyName(key) {
 	return null;
 }
 /**
-* Classifies a layout file by its segment config exports (`dynamic`, `revalidate`).
-*
-* Returns a tagged `LayoutBuildClassification` carrying both the decision and
-* the specific segment-config field that produced it. `{ kind: "absent" }`
-* means no segment config is present and the caller should defer to the next
-* layer (module graph analysis).
-*
-* Unlike page classification, positive `revalidate` values are not meaningful
-* for layout skip decisions — ISR is a page-level concept. Only the extremes
-* (`revalidate = 0` → dynamic, `revalidate = Infinity` → static) are decisive.
-*/
-function classifyLayoutSegmentConfig(code) {
-	const program = parseRouteModule(code);
-	const dynamicValue = program ? extractExportConstStringFromProgram(program, "dynamic") : null;
-	if (dynamicValue === "force-dynamic") return {
-		kind: "dynamic",
-		reason: {
-			layer: "segment-config",
-			key: "dynamic",
-			value: "force-dynamic"
-		}
-	};
-	if (dynamicValue === "force-static" || dynamicValue === "error") return {
-		kind: "static",
-		reason: {
-			layer: "segment-config",
-			key: "dynamic",
-			value: dynamicValue
-		}
-	};
-	const revalidateValue = program ? extractExportConstNumberFromProgram(program, "revalidate") : null;
-	if (revalidateValue === Infinity) return {
-		kind: "static",
-		reason: {
-			layer: "segment-config",
-			key: "revalidate",
-			value: Infinity
-		}
-	};
-	if (revalidateValue === 0) return {
-		kind: "dynamic",
-		reason: {
-			layer: "segment-config",
-			key: "revalidate",
-			value: 0
-		}
-	};
-	return { kind: "absent" };
-}
-/**
 * Classifies a Pages Router page file by reading its source and examining
 * which data-fetching exports it contains.
 *
@@ -675,4 +625,4 @@ async function printBuildReport(options) {
 	}
 }
 //#endregion
-export { buildReportRows, classifyAppRoute, classifyAppRouteHandler, classifyLayoutSegmentConfig, classifyPagesRoute, extractExportConstNumber, extractExportConstString, extractGetStaticPropsRevalidate, extractMiddlewareMatcherConfig, extractMiddlewareMatcherConfigValue, formatBuildReport, getAppRouteRenderEntryPath, hasExportedName, hasNamedExport, hasRuntimeExportedName, printBuildReport };
+export { buildReportRows, classifyAppRoute, classifyAppRouteHandler, classifyPagesRoute, extractExportConstNumber, extractExportConstString, extractGetStaticPropsRevalidate, extractMiddlewareMatcherConfig, extractMiddlewareMatcherConfigValue, formatBuildReport, getAppRouteRenderEntryPath, hasExportedName, hasNamedExport, hasRuntimeExportedName, printBuildReport };

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

@@ -59,4 +59,5 @@ export declare function assertNoFatalPrerenderRoutes(routes: readonly PrerenderR
  * Statically generate routes and return the prerender result.
  */
 export declare function runPrerender(options: RunPrerenderOptions): Promise<PrerenderResult | null>;
-//#endregion
+//#endregion
+export {};

package/dist/build/server-actions-encryption-key.d.ts

@@ -20,4 +20,5 @@ export declare function loadOrGenerateServerActionsEncryptionKey(options: LoadEn
  * when `server.fs.strict` is false, which turns off Vite's file restrictions.
  */
 export declare function getServerActionsKeyCacheFsDeny(configuredDeny: string[] | undefined): string[];
-//#endregion
+//#endregion
+export {};

package/dist/build/ssr-manifest.js

@@ -62,13 +62,36 @@ function augmentSsrManifestFromBundle(ssrManifest, bundle, root, base = "/") {
 		if (!nextManifest[normalizedKey]) nextManifest[normalizedKey] = /* @__PURE__ */ new Set();
 		for (const file of files) nextManifest[normalizedKey].add(collapseDuplicateBase(file, base));
 	}
+	const staticImportClosures = /* @__PURE__ */ new Map();
+	const getStaticImportClosure = (fileName) => {
+		let closure = staticImportClosures.get(fileName);
+		if (closure) return closure;
+		const files = /* @__PURE__ */ new Set();
+		const visit = (importer) => {
+			const chunk = bundle[importer];
+			if (chunk?.type !== "chunk") return;
+			for (const importedFile of chunk.imports ?? []) {
+				if (importedFile === fileName || files.has(importedFile)) continue;
+				files.add(importedFile);
+				visit(importedFile);
+			}
+		};
+		visit(fileName);
+		closure = [...files];
+		staticImportClosures.set(fileName, closure);
+		return closure;
+	};
 	for (const item of Object.values(bundle)) {
 		if (item.type !== "chunk") continue;
 		const chunk = item;
-		if (chunk.fileName.endsWith(".js") && (isSharedClientChunkName(chunk.name) || chunk.isEntry && isPagesClientEntryFacade(chunk.facadeModuleId))) sharedChunkFiles.add(manifestFileWithBase(chunk.fileName, base));
+		if (chunk.fileName.endsWith(".js") && isSharedClientChunkName(chunk.name)) sharedChunkFiles.add(manifestFileWithBase(chunk.fileName, base));
+		if (chunk.isEntry && isPagesClientEntryFacade(chunk.facadeModuleId)) {
+			sharedChunkFiles.add(manifestFileWithBase(chunk.fileName, base));
+			for (const importedFile of getStaticImportClosure(chunk.fileName)) sharedChunkFiles.add(manifestFileWithBase(importedFile, base));
+		}
 		const files = /* @__PURE__ */ new Set();
 		files.add(manifestFileWithBase(chunk.fileName, base));
-		for (const importedFile of chunk.imports ?? []) files.add(manifestFileWithBase(importedFile, base));
+		for (const importedFile of getStaticImportClosure(chunk.fileName)) files.add(manifestFileWithBase(importedFile, base));
 		for (const cssFile of chunk.viteMetadata?.importedCss ?? []) files.add(manifestFileWithBase(cssFile, base));
 		for (const assetFile of chunk.viteMetadata?.importedAssets ?? []) files.add(manifestFileWithBase(assetFile, base));
 		for (const moduleId of Object.keys(chunk.modules ?? {})) {

package/dist/build/standalone.d.ts

@@ -27,4 +27,5 @@ type StandaloneBuildResult = {
  * included.
  */
 export declare function emitStandaloneOutput(options: StandaloneBuildOptions): StandaloneBuildResult;
-//#endregion
+//#endregion
+export {};

package/dist/cache/cache-adapters-virtual.d.ts

@@ -132,4 +132,5 @@ export declare function loadVinextCacheConfigFromViteConfig(vite: ViteConfigLoad
 export declare function generateCacheAdaptersModule(cache?: VinextCacheConfig): string;
 /** Generate request-stage registration without importing a configured data adapter. */
 export declare function generateCdnCacheAdapterModule(cache?: VinextCacheConfig): string;
-//#endregion
+//#endregion
+export {};

package/dist/cache.js

@@ -1,2 +1 @@
-import { cacheForRequest } from "./shims/cache-for-request.js";
-export { cacheForRequest };
+export { cacheForRequest } from "./shims/cache-for-request.js";

package/dist/check.d.ts

@@ -85,4 +85,5 @@ export declare function runCheck(root: string): CheckResult;
 export declare function formatReport(result: CheckResult, opts?: {
   calledFromInit?: boolean;
 }): string;
-//#endregion
+//#endregion
+export {};

package/dist/check.js

@@ -323,6 +323,10 @@ const CONFIG_SUPPORT = {
 		status: "partial",
 		detail: "experimental support; behavior is incomplete"
 	},
+	"experimental.cacheComponents": {
+		status: "partial",
+		detail: "legacy alias of cacheComponents; experimental support, behavior is incomplete"
+	},
 	"experimental.ppr": {
 		status: "unsupported",
 		detail: "removed in Next.js 16 and ignored; use cacheComponents"
@@ -434,7 +438,7 @@ const LIBRARY_SUPPORT = {
 	},
 	"next-intl": {
 		status: "supported",
-		detail: "createNextIntlPlugin is only optional with the request config at (src/)i18n/request.*; its experimental messages, precompile and extract options don't work (they need webpack/Turbopack loaders)"
+		detail: "createNextIntlPlugin is only optional with the request config at (src/)i18n/request.*; its experimental extract option doesn't work (it needs a webpack/Turbopack loader)"
 	},
 	"@clerk/nextjs": {
 		status: "supported",

package/dist/cli-args.d.ts

@@ -21,4 +21,5 @@ type ParsedArgs = {
  * arguments directly to Vite.
  */
 export declare function parseArgs(args: string[]): ParsedArgs;
-//#endregion
+//#endregion
+export {};

package/dist/cli.js

@@ -125,6 +125,7 @@ async function proxyVite(command) {
 async function start() {
 	const parsed = parseArgs(rawArgs);
 	if (parsed.help) return printHelp("start");
+	if (!process.env.NODE_ENV) Reflect.set(process.env, "NODE_ENV", "production");
 	loadDotenv({
 		root: process.cwd(),
 		mode: "production"
@@ -194,6 +195,7 @@ async function check() {
 async function typegen() {
 	const parsed = parseArgs(rawArgs);
 	if (parsed.help) return printHelp("typegen");
+	if (!process.env.NODE_ENV) Reflect.set(process.env, "NODE_ENV", "production");
 	const root = path.resolve(parsed.positionals?.[0] ?? process.cwd());
 	loadDotenv({
 		root,
@@ -282,6 +284,9 @@ function printHelp(cmd) {
                          (Response Store or Workers Cache, default: prompt with No)
     --legacy-wrangler-cloudflare-init
                          Use the legacy Wrangler setup instead of cf
+    --ignore-wrangler-config
+                         Set up cf even if a root Wrangler config exists
+                         (use when it belongs to an unrelated Worker)
     --cdn-cache <type>   Cloudflare CDN cache: none, response-store, workers-cache,
                          static-assets, or data-cache
                          (default: none; response-store is the default cache choice)

package/dist/client/client-redirect-matcher.js

@@ -11,7 +11,8 @@ function getMatcherRule(redirect) {
 			has: redirect.has,
 			missing: redirect.missing,
 			locale: redirect.locale,
-			basePath: redirect.basePath
+			basePath: redirect.basePath,
+			defaultLocaleVariant: redirect.defaultLocaleVariant
 		}];
 		matcherRules.set(redirect, rule);
 	}