vinext 1.3.0 → 1.3.1

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
@@ -187,4 +196,5 @@ export declare function assertClientOutDirIsSeparate(root: string, dirs: {
  * seen to evaluate modules out of order and break hydration.
  */
 export declare function hasUserClientChunkGroups(output: unknown, ownGroups: ReadonlySet<unknown>): boolean;
-//#endregion
+//#endregion
+export {};

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

@@ -10,6 +10,7 @@ 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",
@@ -20,6 +21,31 @@ const ROUTE_OWNED_CLIENT_SHIMS = /* @__PURE__ */ new Set([
 	"script",
 	"web-vitals"
 ]);
+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) {
@@ -65,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
@@ -90,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;
@@ -410,4 +447,4 @@ 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, createClientManualChunks, createClientOutputFileNameDefaults, createMultiStageChunkFileNames, createMultiStageCodeSplittingConfig, createRscFrameworkChunkOutputConfig, createWorkerFileNames, findUnsupportedClientOutputFileNames, getBuildBundlerOptions, getClientTreeshakeConfig, getOutputFileNames, hasUserClientChunkGroups, 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 };

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

@@ -0,0 +1,48 @@
+//#region src/build/client-reference-async.d.ts
+type AsyncModuleGraphInfo = {
+  code: string | null;
+  importedIds: readonly string[];
+};
+/** A chunk of the emitted output, as `renderChunk`'s `meta.chunks` lists it. */
+export type EmittedChunk = {
+  fileName: string;
+  /** The chunks it imports statically, by file name, and its externals. */
+  imports: readonly string[];
+  /** Its modules, with their code after tree-shaking. */
+  modules: Readonly<Record<string, {
+    code: string | null;
+    renderedLength: number;
+  }>>;
+};
+/**
+ * Whether `code` awaits at the top level of the module: an `await`, a
+ * `for await` or an `await using` outside any function. Code that fails to
+ * parse counts as synchronous.
+ */
+export declare function hasTopLevelAwait(code: string): boolean;
+/**
+ * The `roots` whose evaluation is asynchronous in the emitted output: the
+ * module, or a module it imports at any depth, awaits at its top level. Webpack
+ * calls these async modules, and React's Flight client suspends on them as they
+ * load. Only what the output keeps counts: modules tree-shaking dropped don't
+ * make a module async. Neither do imports of a module in a chunk the
+ * importer's chunks never load, nor of one `declaresSideEffects` reports, which
+ * the output drops when unused. Other imports stay: the imported module's side
+ * effects, its await included, run before the importer.
+ */
+export declare function collectAsyncModules(options: {
+  roots: readonly string[];
+  getModuleInfo: (id: string) => AsyncModuleGraphInfo | null;
+  chunks: readonly EmittedChunk[];
+  declaresSideEffects?: (id: string) => boolean;
+}): Set<string>;
+/**
+ * Whether a module's package declares which of its modules have side effects
+ * (`sideEffects` other than `true` in the nearest package.json naming a
+ * package or declaring it). A bundler drops an unused import of a module the
+ * declaration marks side-effect-free, which Rolldown's module info doesn't
+ * report, so an import into such a package may not survive.
+ */
+export declare function createSideEffectsDeclarationCheck(): (id: string) => boolean;
+//#endregion
+export {};

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

@@ -0,0 +1,123 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { parseProgram, walkAst } from "../plugins/ast-utils.js";
+import fs from "node:fs";
+//#region src/build/client-reference-async.ts
+/**
+* Whether `code` awaits at the top level of the module: an `await`, a
+* `for await` or an `await using` outside any function. Code that fails to
+* parse counts as synchronous.
+*/
+function hasTopLevelAwait(code) {
+	if (!code.includes("await")) return false;
+	let program;
+	try {
+		program = parseProgram(code, { sourceType: "module" });
+	} catch {
+		return false;
+	}
+	let found = false;
+	walkAst(program, (node) => {
+		if (found) return false;
+		if (node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") return false;
+		if (node.type === "AwaitExpression") {
+			found = true;
+			return false;
+		}
+		if (node.type === "ForOfStatement" && node.await || node.type === "VariableDeclaration" && node.kind === "await using") found = true;
+	});
+	return found;
+}
+/**
+* The `roots` whose evaluation is asynchronous in the emitted output: the
+* module, or a module it imports at any depth, awaits at its top level. Webpack
+* calls these async modules, and React's Flight client suspends on them as they
+* load. Only what the output keeps counts: modules tree-shaking dropped don't
+* make a module async. Neither do imports of a module in a chunk the
+* importer's chunks never load, nor of one `declaresSideEffects` reports, which
+* the output drops when unused. Other imports stay: the imported module's side
+* effects, its await included, run before the importer.
+*/
+function collectAsyncModules(options) {
+	const chunkOf = /* @__PURE__ */ new Map();
+	for (const chunk of options.chunks) for (const [id, module] of Object.entries(chunk.modules)) if (module.renderedLength > 0) chunkOf.set(id, chunk);
+	const chunksByFile = new Map(options.chunks.map((chunk) => [chunk.fileName, chunk]));
+	const loadedChunks = /* @__PURE__ */ new Map();
+	const chunksLoadedWith = (chunk) => {
+		let files = loadedChunks.get(chunk);
+		if (files) return files;
+		files = /* @__PURE__ */ new Set([chunk.fileName]);
+		const queue = [chunk];
+		for (let index = 0; index < queue.length; index++) for (const file of queue[index].imports) {
+			const imported = chunksByFile.get(file);
+			if (!imported || files.has(file)) continue;
+			files.add(file);
+			queue.push(imported);
+		}
+		loadedChunks.set(chunk, files);
+		return files;
+	};
+	const importers = /* @__PURE__ */ new Map();
+	const awaiting = [];
+	const visited = /* @__PURE__ */ new Set();
+	const stack = options.roots.filter((id) => chunkOf.has(id));
+	while (stack.length > 0) {
+		const id = stack.pop();
+		if (visited.has(id)) continue;
+		visited.add(id);
+		const chunk = chunkOf.get(id);
+		const info = options.getModuleInfo(id);
+		const code = chunk.modules[id].code ?? info?.code ?? null;
+		if (code !== null && hasTopLevelAwait(code)) awaiting.push(id);
+		const loaded = chunksLoadedWith(chunk);
+		for (const imported of info?.importedIds ?? []) {
+			const importedChunk = chunkOf.get(imported);
+			if (!importedChunk || !loaded.has(importedChunk.fileName)) continue;
+			if (options.declaresSideEffects?.(imported)) continue;
+			let list = importers.get(imported);
+			if (!list) importers.set(imported, list = []);
+			list.push(id);
+			stack.push(imported);
+		}
+	}
+	const asyncModules = new Set(awaiting);
+	for (let index = 0; index < awaiting.length; index++) for (const importer of importers.get(awaiting[index]) ?? []) {
+		if (asyncModules.has(importer)) continue;
+		asyncModules.add(importer);
+		awaiting.push(importer);
+	}
+	return new Set(options.roots.filter((id) => asyncModules.has(id)));
+}
+/**
+* Whether a module's package declares which of its modules have side effects
+* (`sideEffects` other than `true` in the nearest package.json naming a
+* package or declaring it). A bundler drops an unused import of a module the
+* declaration marks side-effect-free, which Rolldown's module info doesn't
+* report, so an import into such a package may not survive.
+*/
+function createSideEffectsDeclarationCheck() {
+	const byDirectory = /* @__PURE__ */ new Map();
+	const declares = (directory) => {
+		const cached = byDirectory.get(directory);
+		if (cached !== void 0) return cached;
+		let pkg;
+		try {
+			pkg = JSON.parse(fs.readFileSync(path.join(directory, "package.json"), "utf8"));
+		} catch {
+			pkg = void 0;
+		}
+		let result;
+		if (pkg && typeof pkg === "object" && ("sideEffects" in pkg || "name" in pkg)) result = "sideEffects" in pkg && pkg.sideEffects !== true;
+		else {
+			const parent = path.dirname(directory);
+			result = parent !== directory && declares(parent);
+		}
+		byDirectory.set(directory, result);
+		return result;
+	};
+	return (id) => {
+		const file = id.split("?")[0];
+		return !id.startsWith("\0") && path.isAbsolute(file) && declares(path.dirname(file));
+	};
+}
+//#endregion
+export { collectAsyncModules, createSideEffectsDeclarationCheck, hasTopLevelAwait };

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

@@ -0,0 +1,32 @@
+import { ClientReferenceChunks } from "../utils/client-reference-chunks.js";
+import { ResolvedConfig, Rollup } from "vite";
+//#region src/build/client-reference-chunks.d.ts
+/**
+ * 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.
+ */
+export declare function collectClientReferenceChunks(bundle: Rollup.OutputBundle, moduleKeys: ReadonlyMap<string, readonly string[]>, appBrowserEntry: Rollup.OutputChunk | undefined, modulePreload?: ResolvedConfig["build"]["modulePreload"]): ClientReferenceChunks | undefined;
+/**
+ * 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.
+ */
+export declare function collectClientReferenceSources(bundle: Rollup.OutputBundle, getImportedIds: (moduleId: string) => readonly string[] | undefined, root: string): Record<string, string> | undefined;
+//#endregion