vinext 1.3.0 → 1.4.0

package/README.md

@@ -137,7 +137,7 @@ files to `.cjs`) when an unambiguous default Vite config requires the ESM migrat
 `"type": "commonjs"` is never changed. Direct `vite dev` and `vite build` do not perform these
 wrapper compatibility steps.
 
-`@vinext/cloudflare deploy` options: `--preview`, `--env <name>`, `--name <name>`, `--skip-build`, `--dry-run`, `--warm-cache`, `--traffic-aware-warm-cache`.
+`@vinext/cloudflare deploy` options: `--preview`, `--env <name>`, `--name <name>`, `--vite-config <path>`, `--skip-build`, `--dry-run`, `--warm-cache`, `--traffic-aware-warm-cache`.
 
 `vinext init` prompts for a deployment target, defaulting to Cloudflare. Agents must ask the
 user which target they want, then pass `--platform=cloudflare` or `--platform=node`.
@@ -147,6 +147,8 @@ Other options: `--port <port>` (default: 3001), `--skip-check`, `--force`.
 Cloudflare init uses `cf` and `cloudflare.config.ts` by default. Both `vinext init`
 and `create-vinext-app` accept `--legacy-wrangler-cloudflare-init` to retain the
 legacy Wrangler setup. Existing Wrangler configs are not automatically migrated.
+If a root Wrangler config belongs to another Worker, `vinext init --ignore-wrangler-config`
+sets up `cloudflare.config.ts` and leaves that file untouched.
 `vinext init --name <name>` sets the Worker name in the generated config instead of
 deriving it from `package.json`. An existing config keeps its own Worker name, and init
 prints a warning.
@@ -360,7 +362,8 @@ The init command also auto-detects and fixes common migration issues:
 - Resolves tsconfig.json path aliases automatically with Vite's native resolver
 - Detects MDX usage and configures `@mdx-js/rollup`
 - Renames CJS config files (postcss.config.js, etc.) to `.cjs` when needed
-- Detects native Node.js modules (sharp, resvg, satori, lightningcss, @napi-rs/canvas) and auto-stubs them for Workers. If you encounter others that need stubbing, PRs are welcome.
+
+vinext does not stub native Node.js modules such as `sharp`, `@resvg/resvg-js` or `@napi-rs/canvas`. Workers cannot load Node-API addons, so importing one into Worker code fails the build or the request. If a dependency imports one on a code path that never runs on Workers, alias it to a module of your own with `resolve.alias` in `vite.config.ts`. Configs generated by earlier versions of `vinext init` may contain `resolve.alias` entries pointing at `empty-stub.js`, a file init never created; delete them.
 
 Both App Router and Pages Router work on Workers with full client-side hydration.
 

package/THIRD_PARTY_LICENSES.md

@@ -49,3 +49,50 @@ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+## iconv-lite (version 0.4.24)
+
+Copyright (c) 2011 Alexander Shtuchkin
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+## safer-buffer (version 2.1.2)
+
+MIT License
+
+Copyright (c) 2018 Nikita Skovoroda <chalkerx@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/_virtual/_rolldown/runtime.js

@@ -1,4 +1,4 @@
-import "node:module";
+import { createRequire } from "node:module";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -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];
@@ -21,5 +21,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	value: mod,
 	enumerable: true
 }) : target, mod));
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
 //#endregion
-export { __commonJSMin, __toESM };
+export { __commonJSMin, __require, __toESM };

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