vinext 1.3.0 → 1.4.0

package/dist/shims/slot.js

@@ -1,10 +1,10 @@
 "use client";
 import { APP_BFCACHE_SEGMENT_IDENTITIES_KEY, AppElementsWire, UNMATCHED_SLOT } from "../server/app-elements-wire.js";
 import "../server/app-elements.js";
-import { getBfcacheIdMapContext, getBfcacheSegmentIdContext } from "./navigation-context-state.js";
+import { isNestedBfcacheSlotSegmentId, isNestedBfcacheSlotSegmentIdFor } from "../server/bfcache-identity.js";
 import { notFound } from "./navigation-errors.js";
+import { getBfcacheIdMapContext, getBfcacheSegmentIdContext } from "./navigation-context-state.js";
 import "./navigation-server.js";
-import { isNestedBfcacheSlotSegmentId, isNestedBfcacheSlotSegmentIdFor } from "../server/bfcache-identity.js";
 import * as React$1 from "react";
 import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
 //#region src/shims/slot.tsx
@@ -92,11 +92,6 @@ function stageBfcacheSlotEntryForRender(committedSnapshots, committedOrder, acti
 		snapshots
 	};
 }
-function isLayoutFlagsValue(value) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	const entries = Object.values(value);
-	return entries.length > 0 && entries.every((entry) => entry === "s" || entry === "d");
-}
 function isArtifactCompatibilityEnvelopeValue(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
 	return "schemaVersion" in value && "appElementsSchemaVersion" in value && "rscPayloadSchemaVersion" in value && "graphVersion" in value && "deploymentVersion" in value && "rootBoundaryId" in value && "renderEpoch" in value;
@@ -127,7 +122,7 @@ function isCacheEntryReuseProofValue(value) {
 	return "kind" in value && value.kind === "runtime-cache-entry" && "decision" in value;
 }
 function isTransportMetadataValue(id, value) {
-	return isLayoutFlagsValue(value) || isBfcacheSegmentIdentitiesMetadataValue(id, value) || isArtifactCompatibilityEnvelopeValue(value) || isCacheEntryReuseProofValue(value) || isInterceptionMetadataValue(value) || isSkippedLayoutIdsMetadataValue(id, value) || isSlotBindingListValue(value);
+	return isBfcacheSegmentIdentitiesMetadataValue(id, value) || isArtifactCompatibilityEnvelopeValue(value) || isCacheEntryReuseProofValue(value) || isInterceptionMetadataValue(value) || isSkippedLayoutIdsMetadataValue(id, value) || isSlotBindingListValue(value);
 }
 function warnTransportMetadataEntry(id) {
 	if (process.env.NODE_ENV === "production") return;
@@ -210,6 +205,39 @@ function BfcacheSegmentBoundary({ children, id, stateKey }) {
 		stateKeyMap: identityMap
 	});
 }
+/**
+* Retains a layout's children across navigations that change which segment
+* they render. Each child keeps its own wrappers, so a page and a nested layout
+* give the layout's children different element shapes, and a retention list
+* inside the child would remount with them. Next.js keeps this Activity list in
+* the parent's layout router, above the child's boundaries, so a page left for a
+* sibling with its own layout keeps its state when navigating back.
+*/
+function BfcacheChildrenBoundary({ children, id }) {
+	if (!BfcacheIdMapContext || !BfcacheSegmentIdContext || !isCacheComponentsEnabled()) return /* @__PURE__ */ jsx(Fragment$1, { children });
+	return /* @__PURE__ */ jsx(BfcacheChildrenActivityBoundary, {
+		id,
+		IdMapContext: BfcacheIdMapContext,
+		SegmentContext: BfcacheSegmentIdContext,
+		children
+	});
+}
+function BfcacheChildrenActivityBoundary({ children, id, IdMapContext, SegmentContext }) {
+	const elements = React$1.useContext(ElementsContext);
+	const identityMap = React$1.useContext(BfcacheIdentityMapContext);
+	const bfcacheIdMap = React$1.useContext(IdMapContext);
+	const segmentId = React$1.useContext(SegmentContext);
+	const activeStateKey = resolveBfcacheSegmentStateKey(id, identityMap, bfcacheIdMap);
+	if (segmentId === null || activeStateKey === void 0) return /* @__PURE__ */ jsx(Fragment$1, { children });
+	return /* @__PURE__ */ jsx(BfcacheActivitySlotBoundary, {
+		activeStateKey,
+		content: children,
+		elements,
+		id: segmentId,
+		SegmentContext,
+		stateKeyMap: identityMap
+	});
+}
 function getNonCacheComponentsSegmentKey(id, activeStateKey) {
 	const parsed = AppElementsWire.parseElementKey(id);
 	return parsed !== null && parsed.kind !== "route" ? activeStateKey : void 0;
@@ -340,4 +368,4 @@ function ParallelSlot({ name }) {
 	return React$1.useContext(ParallelSlotsContext)?.[name] ?? null;
 }
 //#endregion
-export { BfcacheIdentityMapContext, BfcacheSegmentBoundary, Children, ChildrenContext, ElementsContext, ParallelSlot, ParallelSlotsContext, RenderedSearchContext, Slot, UNMATCHED_SLOT, bindAppElementsRenderedSearch, getNonCacheComponentsSegmentKey, mergeElements, resolveBfcacheSegmentStateKey, setAppElementsRenderedSearch, stageBfcacheSlotEntryForRender, updateBfcacheSlotEntryOrder };
+export { BfcacheChildrenBoundary, BfcacheIdentityMapContext, BfcacheSegmentBoundary, Children, ChildrenContext, ElementsContext, ParallelSlot, ParallelSlotsContext, RenderedSearchContext, Slot, UNMATCHED_SLOT, bindAppElementsRenderedSearch, getNonCacheComponentsSegmentKey, mergeElements, resolveBfcacheSegmentStateKey, setAppElementsRenderedSearch, stageBfcacheSlotEntryForRender, updateBfcacheSlotEntryOrder };

package/dist/shims/unified-request-context.d.ts

@@ -1,8 +1,8 @@
 import { ExecutionContextLike } from "./request-context.js";
-import { CacheState } from "./cache-request-state.js";
 import { RootParamsState } from "./root-params.js";
 import { FetchCacheState } from "./fetch-cache-state.js";
 import { VinextHeadersShimState } from "./internal/headers-state.js";
+import { CacheState } from "./cache-request-state.js";
 import { RouterState } from "./router-state.js";
 import { markFullyBufferedBody, preserveFullyBufferedBodyMetadata } from "../server/fully-buffered-response.js";
 import { PrivateCacheState } from "./cache-runtime.js";

package/dist/shims/unified-request-context.js

@@ -1,5 +1,6 @@
 import { getOrCreateAls } from "./internal/als-registry.js";
 import { isFullyBufferedBody, markFullyBufferedBody, preserveFullyBufferedBodyMetadata } from "../server/fully-buffered-response.js";
+import { deferUntilStreamConsumed } from "../server/defer-until-stream-consumed.js";
 //#region src/shims/unified-request-context.ts
 const _REQUEST_CONTEXT_ALS_KEY = Symbol.for("vinext.requestContext.als");
 const _g = globalThis;
@@ -17,7 +18,7 @@ function createRequestContext(opts) {
 	return {
 		headersContext: null,
 		actionRevalidationKind: 0,
-		cacheLifeSink: null,
+		isOnDemandRevalidate: false,
 		pendingCdnTagInvalidations: [],
 		pendingRevalidatedTags: /* @__PURE__ */ new Set(),
 		pendingRevalidations: /* @__PURE__ */ new Set(),
@@ -36,15 +37,14 @@ function createRequestContext(opts) {
 		serverContext: null,
 		serverInsertedHTMLCallbacks: [],
 		requestScopedCacheLife: null,
-		unstableCacheObservations: /* @__PURE__ */ new Map(),
 		unstableCacheRevalidation: "foreground",
 		_privateCache: null,
-		cacheableFetchUrls: /* @__PURE__ */ new Set(),
 		currentRequestTags: [],
 		currentFetchSoftTags: [],
 		currentFetchCacheMode: null,
 		currentFetchRevalidate: null,
 		currentForceDynamicFetchDefault: false,
+		isDraftMode: false,
 		dynamicFetchUrls: /* @__PURE__ */ new Set(),
 		refreshStaleFetchesInForeground: false,
 		isFetchDedupeActive: false,
@@ -161,9 +161,8 @@ function closeAfterResponseWithBody(response, ctx) {
 		return response;
 	}
 	if (isFullyBufferedBody(response) && !requiresResponseCloseTracking(ctx)) return response;
-	const passthrough = new TransformStream();
-	response.body.pipeTo(passthrough.writable).then(() => void closeAfterResponse(ctx), () => void closeAfterResponse(ctx));
-	const wrapped = new Response(passthrough.readable, {
+	const body = deferUntilStreamConsumed(response.body, () => void closeAfterResponse(ctx));
+	const wrapped = new Response(body, {
 		status: response.status,
 		statusText: response.statusText,
 		headers: response.headers

package/dist/typegen.d.ts

@@ -10,4 +10,5 @@ export type GenerateRouteTypesResult = {
   nextEnvStatus: "created" | "updated" | "unchanged";
 };
 export declare function generateRouteTypes(options: GenerateRouteTypesOptions): Promise<GenerateRouteTypesResult>;
-//#endregion
+//#endregion
+export {};

package/dist/utils/cache-control-metadata.d.ts

@@ -1,5 +1,10 @@
 //#region src/utils/cache-control-metadata.d.ts
 export declare function readCacheControlNumberField(ctx: Record<string, unknown> | undefined, field: string): number | undefined;
+/**
+ * When a `"use cache"` entry's generation started (`ctx.timestamp`), which dates
+ * the entry like Next.js does. Absent, malformed or future values fall back to `now`.
+ */
+export declare function readCacheTimestamp(ctx: Record<string, unknown> | undefined, now: number): number;
 export declare function readCacheControlRevalidateField(ctx: Record<string, unknown> | undefined): number | false | undefined;
 /**
  * Client-reuse seconds from a resolved `cacheLife`. Shared by every emitter

package/dist/utils/cache-control-metadata.js

@@ -8,6 +8,14 @@ function readCacheControlNumberField(ctx, field) {
 	const value = readRecordField(ctx, "cacheControl")?.[field] ?? ctx?.[field];
 	return typeof value === "number" ? value : void 0;
 }
+/**
+* When a `"use cache"` entry's generation started (`ctx.timestamp`), which dates
+* the entry like Next.js does. Absent, malformed or future values fall back to `now`.
+*/
+function readCacheTimestamp(ctx, now) {
+	const value = ctx?.timestamp;
+	return typeof value === "number" && Number.isFinite(value) && value > 0 && value <= now ? value : now;
+}
 function readCacheControlRevalidateField(ctx) {
 	const value = readRecordField(ctx, "cacheControl")?.revalidate ?? ctx?.revalidate;
 	return typeof value === "number" || value === false ? value : void 0;
@@ -29,4 +37,4 @@ function resolveClientStaleTimeSeconds(cacheLife) {
 	return isFiniteNonNegative(stale) ? stale : void 0;
 }
 //#endregion
-export { readCacheControlNumberField, readCacheControlRevalidateField, resolveClientStaleTimeSeconds };
+export { readCacheControlNumberField, readCacheControlRevalidateField, readCacheTimestamp, resolveClientStaleTimeSeconds };

package/dist/utils/client-build-manifest.d.ts

@@ -4,6 +4,8 @@ type ClientBuildManifest = Record<string, BuildManifestChunk>;
 export declare function readClientBuildManifest(manifestPath: string): ClientBuildManifest | undefined;
 export declare function findClientEntryFileFromManifest(buildManifest: ClientBuildManifest, assetBase: string): string | undefined;
 export declare function findPagesClientEntryFileFromManifest(buildManifest: ClientBuildManifest, assetBase: string): string | undefined;
+/** Whether a build-manifest entry is the Pages Router client entry. */
+export declare function isPagesClientEntryChunk(key: string, entry: BuildManifestChunk): boolean;
 export declare function findClientEntryFile(options: {
   buildManifest?: ClientBuildManifest;
   clientDir: string;
@@ -16,4 +18,5 @@ export declare function findPagesClientEntryFile(options: {
   assetsSubdir: string;
   assetBase: string;
 }): string | undefined;
-//#endregion
+//#endregion
+export {};

package/dist/utils/client-build-manifest.js

@@ -42,7 +42,7 @@ function findPagesClientEntryFileFromManifest(buildManifest, assetBase) {
 }
 function findEntryFileFromManifest(buildManifest, assetBase, markers, fallbackToFirstEntry) {
 	const entries = Object.entries(buildManifest).filter(([, entry]) => entry.isEntry && entry.file);
-	const matchers = [(marker, key, entry) => entry.name === marker || isVirtualEntryId(key, marker) || entry.src !== void 0 && isVirtualEntryId(entry.src, marker), (marker, _key, entry) => entry.file.includes(marker)];
+	const matchers = [matchesEntryIdentity, (marker, _key, entry) => entry.file.includes(marker)];
 	for (const matches of matchers) for (const marker of markers) {
 		const markedEntry = entries.find(([key, entry]) => matches(marker, key, entry));
 		if (markedEntry) return manifestFileWithBase(markedEntry[1].file, assetBase);
@@ -50,6 +50,13 @@ function findEntryFileFromManifest(buildManifest, assetBase, markers, fallbackTo
 	const chosen = fallbackToFirstEntry ? entries[0]?.[1] : void 0;
 	return chosen ? manifestFileWithBase(chosen.file, assetBase) : void 0;
 }
+function matchesEntryIdentity(marker, key, entry) {
+	return entry.name === marker || isVirtualEntryId(key, marker) || entry.src !== void 0 && isVirtualEntryId(entry.src, marker);
+}
+/** Whether a build-manifest entry is the Pages Router client entry. */
+function isPagesClientEntryChunk(key, entry) {
+	return entry.isEntry === true && PAGES_CLIENT_ENTRY_MARKERS.some((marker) => matchesEntryIdentity(marker, key, entry));
+}
 function isVirtualEntryId(id, marker) {
 	const virtualId = `virtual:${marker}`;
 	return id === virtualId || id.endsWith(`/${virtualId}`);
@@ -92,4 +99,4 @@ function readStringArray(value) {
 	return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
 }
 //#endregion
-export { findClientEntryFile, findClientEntryFileFromManifest, findPagesClientEntryFile, findPagesClientEntryFileFromManifest, readClientBuildManifest };
+export { findClientEntryFile, findClientEntryFileFromManifest, findPagesClientEntryFile, findPagesClientEntryFileFromManifest, isPagesClientEntryChunk, readClientBuildManifest };

package/dist/utils/client-entry-manifest.d.ts

@@ -1,10 +1,23 @@
+import { ClientReferenceChunks } from "./client-reference-chunks.js";
 //#region src/utils/client-entry-manifest.d.ts
 export declare const VINEXT_CLIENT_ENTRY_MANIFEST = "vinext-client-entry-manifest.json";
+/**
+ * Build manifest keys of App Router client reference modules -> the chunk of
+ * the module that registers the reference (see build/client-reference-chunks.ts).
+ * It names source files, so it sits under `.vite/` with Vite's build manifest,
+ * which deploys leave out of the public assets.
+ */
+export declare const VINEXT_CLIENT_REFERENCE_SOURCES = ".vite/vinext-client-reference-sources.json";
 export type ClientEntryManifest = {
   pagesClientEntry?: string;
   appBrowserEntry?: string;
+  /** The App Router RouteManifest chunk, which the browser entry imports as it boots. */
+  appRouteManifest?: string;
+  /** What each App Router client reference loads in the browser. */
+  appClientReferenceChunks?: ClientReferenceChunks;
 };
 export declare function readClientEntryManifest(clientDir: string): ClientEntryManifest | undefined;
+export declare function readClientReferenceSources(clientDir: string): Record<string, string> | undefined;
 export declare function findClientEntryFileFromVinextManifest(manifest: ClientEntryManifest | undefined, assetBase: string): string | undefined;
 export declare function findPagesClientEntryFileFromVinextManifest(manifest: ClientEntryManifest | undefined, assetBase: string): string | undefined;
 //#endregion

package/dist/utils/client-entry-manifest.js

@@ -4,6 +4,13 @@ import { manifestFileWithBase } from "./manifest-paths.js";
 import fs from "node:fs";
 //#region src/utils/client-entry-manifest.ts
 const VINEXT_CLIENT_ENTRY_MANIFEST = "vinext-client-entry-manifest.json";
+/**
+* Build manifest keys of App Router client reference modules -> the chunk of
+* the module that registers the reference (see build/client-reference-chunks.ts).
+* It names source files, so it sits under `.vite/` with Vite's build manifest,
+* which deploys leave out of the public assets.
+*/
+const VINEXT_CLIENT_REFERENCE_SOURCES = ".vite/vinext-client-reference-sources.json";
 function readClientEntryManifest(clientDir) {
 	const manifestPath = path.join(clientDir, VINEXT_CLIENT_ENTRY_MANIFEST);
 	if (!fs.existsSync(manifestPath)) return void 0;
@@ -13,11 +20,23 @@ function readClientEntryManifest(clientDir) {
 		const manifest = {};
 		if (typeof value.pagesClientEntry === "string") manifest.pagesClientEntry = value.pagesClientEntry;
 		if (typeof value.appBrowserEntry === "string") manifest.appBrowserEntry = value.appBrowserEntry;
+		if (typeof value.appRouteManifest === "string") manifest.appRouteManifest = value.appRouteManifest;
+		if (isUnknownRecord(value.appClientReferenceChunks)) manifest.appClientReferenceChunks = value.appClientReferenceChunks;
 		return manifest.pagesClientEntry || manifest.appBrowserEntry ? manifest : void 0;
 	} catch {
 		return;
 	}
 }
+function readClientReferenceSources(clientDir) {
+	const sourcesPath = path.join(clientDir, VINEXT_CLIENT_REFERENCE_SOURCES);
+	if (!fs.existsSync(sourcesPath)) return void 0;
+	try {
+		const value = JSON.parse(fs.readFileSync(sourcesPath, "utf-8"));
+		return isUnknownRecord(value) ? value : void 0;
+	} catch {
+		return;
+	}
+}
 function findClientEntryFileFromVinextManifest(manifest, assetBase) {
 	const entry = manifest?.pagesClientEntry ?? manifest?.appBrowserEntry;
 	return entry ? manifestFileWithBase(entry, assetBase) : void 0;
@@ -26,4 +45,4 @@ function findPagesClientEntryFileFromVinextManifest(manifest, assetBase) {
 	return manifest?.pagesClientEntry ? manifestFileWithBase(manifest.pagesClientEntry, assetBase) : void 0;
 }
 //#endregion
-export { VINEXT_CLIENT_ENTRY_MANIFEST, findClientEntryFileFromVinextManifest, findPagesClientEntryFileFromVinextManifest, readClientEntryManifest };
+export { VINEXT_CLIENT_ENTRY_MANIFEST, VINEXT_CLIENT_REFERENCE_SOURCES, findClientEntryFileFromVinextManifest, findPagesClientEntryFileFromVinextManifest, readClientEntryManifest, readClientReferenceSources };

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

@@ -0,0 +1,45 @@
+//#region src/utils/client-reference-chunks.d.ts
+/**
+ * The chunks an App Router client reference loads in the browser, which the
+ * RSC render names in the reference's Flight row (see
+ * server/app-client-reference-manifest.ts).
+ */
+export type ClientReferenceChunks = {
+  /** Reference key -> index into `modules`. */
+  references: Record<string, number>;
+  /**
+   * Each chunk that registers client references (see
+   * shims/internal/client-reference-loader.ts), with the JS chunks to
+   * modulepreload (it and the chunks it imports that the browser entry
+   * doesn't, picked by `build.modulePreload`), and the stylesheets they need.
+   */
+  modules: {
+    file: string;
+    imports: string[];
+    css: string[];
+  }[];
+};
+/**
+ * How the browser loads a chunk a Flight row names. React passes the loader
+ * only the chunk id, so the id is the kind followed by the URL.
+ */
+export declare const CLIENT_REFERENCE_CHUNK_KIND: {
+  /**
+   * The chunk that registers the reference, imported once the stylesheets
+   * its id lists after its URL have loaded.
+   */
+  readonly module: "m";
+  /** A JS chunk to modulepreload: the module chunk, or one it imports. */
+  readonly preload: "p";
+};
+/** Separates the URLs in a module chunk's id. A URL can't hold a raw newline. */
+export declare const CLIENT_REFERENCE_CHUNK_URL_SEPARATOR = "\n";
+/**
+ * React's webpack Flight binding takes a client reference's chunks as
+ * `[chunkId, filename, ...]` pairs. Only the id reaches the browser's chunk
+ * loader, so the filenames are left empty. The module chunk's id lists its
+ * stylesheets, so the loader can link them before the chunk evaluates, as
+ * Vite's preload helper does.
+ */
+export declare function toFlightChunks(module: ClientReferenceChunks["modules"][number]): string[];
+//#endregion

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

@@ -0,0 +1,30 @@
+//#region src/utils/client-reference-chunks.ts
+/**
+* How the browser loads a chunk a Flight row names. React passes the loader
+* only the chunk id, so the id is the kind followed by the URL.
+*/
+const CLIENT_REFERENCE_CHUNK_KIND = {
+	/**
+	* The chunk that registers the reference, imported once the stylesheets
+	* its id lists after its URL have loaded.
+	*/
+	module: "m",
+	/** A JS chunk to modulepreload: the module chunk, or one it imports. */
+	preload: "p"
+};
+/** Separates the URLs in a module chunk's id. A URL can't hold a raw newline. */
+const CLIENT_REFERENCE_CHUNK_URL_SEPARATOR = "\n";
+/**
+* React's webpack Flight binding takes a client reference's chunks as
+* `[chunkId, filename, ...]` pairs. Only the id reaches the browser's chunk
+* loader, so the filenames are left empty. The module chunk's id lists its
+* stylesheets, so the loader can link them before the chunk evaluates, as
+* Vite's preload helper does.
+*/
+function toFlightChunks(module) {
+	const chunks = [CLIENT_REFERENCE_CHUNK_KIND.module + [module.file, ...module.css].join("\n"), ""];
+	for (const file of module.imports) chunks.push(CLIENT_REFERENCE_CHUNK_KIND.preload + file, "");
+	return chunks;
+}
+//#endregion
+export { CLIENT_REFERENCE_CHUNK_KIND, CLIENT_REFERENCE_CHUNK_URL_SEPARATOR, toFlightChunks };

package/dist/utils/client-runtime-metadata.d.ts

@@ -1,7 +1,10 @@
+import { ClientReferenceChunks } from "./client-reference-chunks.js";
 //#region src/utils/client-runtime-metadata.d.ts
 type ClientRuntimeMetadata = {
   clientEntryFile?: string;
   appBootstrapPreinitModules?: string[];
+  appRouteManifestModule?: string;
+  appClientReferenceChunks?: ClientReferenceChunks;
   cssGraph?: Record<string, {
     imports?: string[];
     css?: string[];
@@ -14,6 +17,10 @@ type ClientRuntimeMetadata = {
  * Read the client build manifest and compute runtime metadata used by
  * Cloudflare worker entry injection and Node production server startup.
  *
+ * - `appRouteManifestModule` — the App Router RouteManifest chunk, which the
+ *   browser entry imports as it boots, preloaded during SSR.
+ * - `appClientReferenceChunks` — what each App Router client reference loads
+ *   in the browser, which the RSC render names in its Flight row.
  * - `lazyChunks` — chunks only reachable through dynamic `import()`, excluded
  *   from modulepreload hints.
  * - `dynamicPreloads` — per-module JS/CSS files for rendered `next/dynamic()`
@@ -32,4 +39,5 @@ export declare function computeClientRuntimeMetadata(opts: {
   assetPrefix: string;
   includeClientEntry?: boolean | "pages-client-entry";
 }): ClientRuntimeMetadata;
-//#endregion
+//#endregion
+export {};

package/dist/utils/client-runtime-metadata.js

@@ -1,9 +1,9 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { isAbsoluteAssetPrefix, resolveAssetsDir } from "./asset-prefix.js";
 import { isSharedClientChunkName, manifestFileWithAssetPrefix, manifestFileWithBase } from "./manifest-paths.js";
-import { findClientEntryFileFromVinextManifest, findPagesClientEntryFileFromVinextManifest, readClientEntryManifest } from "./client-entry-manifest.js";
-import { findClientEntryFile, findPagesClientEntryFile, readClientBuildManifest } from "./client-build-manifest.js";
-import { computeDynamicImportPreloads, computeLazyChunks, dynamicImportPreloadsWithBase } from "./lazy-chunks.js";
+import { findClientEntryFileFromVinextManifest, findPagesClientEntryFileFromVinextManifest, readClientEntryManifest, readClientReferenceSources } from "./client-entry-manifest.js";
+import { findClientEntryFile, findPagesClientEntryFile, isPagesClientEntryChunk, readClientBuildManifest } from "./client-build-manifest.js";
+import { addDynamicImportPreloadAliases, computeDynamicImportPreloads, computeLazyChunks, dynamicImportPreloadsWithBase } from "./lazy-chunks.js";
 //#region src/utils/client-runtime-metadata.ts
 /**
 * Shared Pages Router chunk files, keyed on Rolldown chunk names rather than
@@ -12,7 +12,20 @@ import { computeDynamicImportPreloads, computeLazyChunks, dynamicImportPreloadsW
 */
 function collectSharedChunkFiles(buildManifest, applyBase) {
 	const files = /* @__PURE__ */ new Set();
-	for (const chunk of Object.values(buildManifest)) if (chunk.file.endsWith(".js") && isSharedClientChunkName(chunk.name)) files.add(applyBase(chunk.file));
+	const visitedKeys = /* @__PURE__ */ new Set();
+	const addStaticImports = (key) => {
+		for (const importedKey of buildManifest[key]?.imports ?? []) {
+			if (visitedKeys.has(importedKey)) continue;
+			visitedKeys.add(importedKey);
+			const importedFile = buildManifest[importedKey]?.file;
+			if (importedFile?.endsWith(".js")) files.add(applyBase(importedFile));
+			addStaticImports(importedKey);
+		}
+	};
+	for (const [key, chunk] of Object.entries(buildManifest)) {
+		if (chunk.file.endsWith(".js") && isSharedClientChunkName(chunk.name)) files.add(applyBase(chunk.file));
+		if (isPagesClientEntryChunk(key, chunk)) addStaticImports(key);
+	}
 	return files.size > 0 ? [...files] : void 0;
 }
 function collectCssGraph(buildManifest, applyBase) {
@@ -56,6 +69,10 @@ function collectAppBootstrapPreinitModules(buildManifest, appBrowserEntry, apply
 * Read the client build manifest and compute runtime metadata used by
 * Cloudflare worker entry injection and Node production server startup.
 *
+* - `appRouteManifestModule` — the App Router RouteManifest chunk, which the
+*   browser entry imports as it boots, preloaded during SSR.
+* - `appClientReferenceChunks` — what each App Router client reference loads
+*   in the browser, which the RSC render names in its Flight row.
 * - `lazyChunks` — chunks only reachable through dynamic `import()`, excluded
 *   from modulepreload hints.
 * - `dynamicPreloads` — per-module JS/CSS files for rendered `next/dynamic()`
@@ -83,18 +100,32 @@ function computeClientRuntimeMetadata(opts) {
 		const entry = opts.includeClientEntry === "pages-client-entry" ? findPagesClientEntryFileFromVinextManifest(clientEntryManifest, opts.assetBase) ?? findPagesClientEntryFile(entryOptions) : findClientEntryFileFromVinextManifest(clientEntryManifest, opts.assetBase) ?? findClientEntryFile(entryOptions);
 		if (entry) metadata.clientEntryFile = entry;
 	}
+	const appAssetUrl = (file) => {
+		const url = manifestFileWithAssetPrefix(file, opts.assetBase, opts.assetPrefix);
+		return isAbsoluteAssetPrefix(opts.assetPrefix) ? url : "/" + url;
+	};
+	const referenceChunks = clientEntryManifest?.appClientReferenceChunks;
+	if (referenceChunks) metadata.appClientReferenceChunks = {
+		references: referenceChunks.references,
+		modules: referenceChunks.modules.map((module) => ({
+			file: appAssetUrl(module.file),
+			imports: module.imports.map(appAssetUrl),
+			css: module.css.map(appAssetUrl)
+		}))
+	};
 	if (!buildManifest) return metadata;
 	if (opts.includeClientEntry) {
 		metadata.cssGraph = collectCssGraph(buildManifest, (file) => manifestFileWithBase(file, opts.assetBase));
 		metadata.sharedChunks = collectSharedChunkFiles(buildManifest, (file) => manifestFileWithBase(file, opts.assetBase));
 	}
-	metadata.appBootstrapPreinitModules = collectAppBootstrapPreinitModules(buildManifest, clientEntryManifest?.appBrowserEntry, (file) => {
-		const url = manifestFileWithAssetPrefix(file, opts.assetBase, opts.assetPrefix);
-		return isAbsoluteAssetPrefix(opts.assetPrefix) ? url : "/" + url;
-	});
+	metadata.appBootstrapPreinitModules = collectAppBootstrapPreinitModules(buildManifest, clientEntryManifest?.appBrowserEntry, appAssetUrl);
+	if (clientEntryManifest?.appRouteManifest) metadata.appRouteManifestModule = appAssetUrl(clientEntryManifest.appRouteManifest);
 	const lazyChunks = computeLazyChunks(buildManifest).map((file) => manifestFileWithBase(file, opts.assetBase));
 	if (lazyChunks.length > 0) metadata.lazyChunks = lazyChunks;
-	const dynamicPreloads = dynamicImportPreloadsWithBase(computeDynamicImportPreloads(buildManifest), (file) => manifestFileWithAssetPrefix(file, opts.assetBase, opts.assetPrefix));
+	const dynamicImportPreloads = computeDynamicImportPreloads(buildManifest);
+	const clientReferenceSources = readClientReferenceSources(opts.clientDir);
+	if (clientReferenceSources) addDynamicImportPreloadAliases(dynamicImportPreloads, buildManifest, clientReferenceSources);
+	const dynamicPreloads = dynamicImportPreloadsWithBase(dynamicImportPreloads, (file) => manifestFileWithAssetPrefix(file, opts.assetBase, opts.assetPrefix));
 	if (Object.keys(dynamicPreloads).length > 0) metadata.dynamicPreloads = dynamicPreloads;
 	return metadata;
 }

package/dist/utils/compare.d.ts

@@ -1,3 +1,12 @@
 //#region src/utils/compare.d.ts
 export declare const compareStrings: (left: string, right: string) => number;
+/**
+ * Turbopack reads a folder's subfolders from a `BTreeMap<RcStr, _>`, whose
+ * keys compare as Rust `str`s: by UTF-8 bytes. That is Unicode code point
+ * order, which JavaScript's `<` (UTF-16 code units) doesn't match above the
+ * Basic Multilingual Plane.
+ * https://github.com/vercel/next.js/blob/v16.2.7/crates/next-core/src/app_structure.rs#L188-L192
+ * https://github.com/vercel/next.js/blob/v16.2.7/turbopack/crates/turbo-rcstr/src/lib.rs#L350-L354
+ */
+export declare function compareFolderNames(a: string, b: string): number;
 //#endregion

package/dist/utils/compare.js

@@ -4,5 +4,19 @@ const compareStrings = (left, right) => {
 	if (left > right) return 1;
 	return 0;
 };
+/**
+* Turbopack reads a folder's subfolders from a `BTreeMap<RcStr, _>`, whose
+* keys compare as Rust `str`s: by UTF-8 bytes. That is Unicode code point
+* order, which JavaScript's `<` (UTF-16 code units) doesn't match above the
+* Basic Multilingual Plane.
+* https://github.com/vercel/next.js/blob/v16.2.7/crates/next-core/src/app_structure.rs#L188-L192
+* https://github.com/vercel/next.js/blob/v16.2.7/turbopack/crates/turbo-rcstr/src/lib.rs#L350-L354
+*/
+function compareFolderNames(a, b) {
+	const left = Array.from(a, (char) => char.codePointAt(0) ?? 0);
+	const right = Array.from(b, (char) => char.codePointAt(0) ?? 0);
+	for (let index = 0; index < Math.min(left.length, right.length); index++) if (left[index] !== right[index]) return left[index] - right[index];
+	return left.length - right.length;
+}
 //#endregion
-export { compareStrings };
+export { compareFolderNames, compareStrings };

package/dist/utils/lazy-chunks.d.ts

@@ -26,6 +26,11 @@ export type BuildManifestChunk = {
  * static `imports` tree (breadth-first). Any chunk file NOT reached by this
  * walk is only reachable through `dynamicImports` and is therefore "lazy".
  *
+ * The Pages Router client entry `import()`s every page and `_app`, but the
+ * HTML for a page renders that page and `_app`, so their chunks are roots of
+ * the walk too: Next.js emits their scripts in the initial HTML. Their own
+ * dynamic imports (next/dynamic, React.lazy) stay lazy.
+ *
  * @param buildManifest - Vite's build manifest (manifest.json), which is a
  *   Record<string, ManifestChunk> where each chunk has `file`, `imports`,
  *   `dynamicImports`, `isEntry`, and `isDynamicEntry` fields.
@@ -58,5 +63,14 @@ export declare function computeLazyChunks(buildManifest: Record<string, BuildMan
  * should be preloaded when that dynamic boundary is rendered.
  */
 export declare function computeDynamicImportPreloads(buildManifest: Record<string, BuildManifestChunk>): Record<string, string[]>;
+/**
+ * Give a module the preloads of a chunk that loads it. The client build
+ * imports an App Router client reference through the module that registers it
+ * (see build/client-reference-chunks.ts), so the build manifest keys that
+ * module's chunk, not the reference's module a next/dynamic boundary names.
+ *
+ * @param aliases Module manifest key -> the file of the chunk that loads it.
+ */
+export declare function addDynamicImportPreloadAliases(preloads: Record<string, string[]>, buildManifest: Record<string, BuildManifestChunk>, aliases: Record<string, string>): void;
 export declare function dynamicImportPreloadsWithBase(preloads: Record<string, string[]>, applyBase: (file: string) => string): Record<string, string[]>;
 //#endregion

package/dist/utils/lazy-chunks.js

@@ -1,3 +1,4 @@
+import { isPagesClientEntryChunk } from "./client-build-manifest.js";
 //#region src/utils/lazy-chunks.ts
 /**
 * Compute the set of chunk filenames that are ONLY reachable through dynamic
@@ -10,6 +11,11 @@
 * static `imports` tree (breadth-first). Any chunk file NOT reached by this
 * walk is only reachable through `dynamicImports` and is therefore "lazy".
 *
+* The Pages Router client entry `import()`s every page and `_app`, but the
+* HTML for a page renders that page and `_app`, so their chunks are roots of
+* the walk too: Next.js emits their scripts in the initial HTML. Their own
+* dynamic imports (next/dynamic, React.lazy) stay lazy.
+*
 * @param buildManifest - Vite's build manifest (manifest.json), which is a
 *   Record<string, ManifestChunk> where each chunk has `file`, `imports`,
 *   `dynamicImports`, `isEntry`, and `isDynamicEntry` fields.
@@ -32,6 +38,9 @@ function computeLazyChunks(buildManifest) {
 		if (chunk.imports) {
 			for (const imp of chunk.imports) if (!visited.has(imp)) queue.push(imp);
 		}
+		if (isPagesClientEntryChunk(key, chunk)) {
+			for (const imp of chunk.dynamicImports ?? []) if (!visited.has(imp)) queue.push(imp);
+		}
 	}
 	const lazyChunks = [];
 	const allFiles = /* @__PURE__ */ new Set();
@@ -103,10 +112,27 @@ function computeDynamicImportPreloads(buildManifest) {
 	}
 	return preloads;
 }
+/**
+* Give a module the preloads of a chunk that loads it. The client build
+* imports an App Router client reference through the module that registers it
+* (see build/client-reference-chunks.ts), so the build manifest keys that
+* module's chunk, not the reference's module a next/dynamic boundary names.
+*
+* @param aliases Module manifest key -> the file of the chunk that loads it.
+*/
+function addDynamicImportPreloadAliases(preloads, buildManifest, aliases) {
+	const keysByFile = /* @__PURE__ */ new Map();
+	for (const [key, chunk] of Object.entries(buildManifest)) keysByFile.set(chunk.file, normalizeManifestKey(key));
+	for (const [moduleKey, file] of Object.entries(aliases)) {
+		const key = keysByFile.get(file);
+		const files = key === void 0 ? void 0 : preloads[key];
+		if (files && !Object.hasOwn(preloads, moduleKey)) preloads[moduleKey] = files;
+	}
+}
 function dynamicImportPreloadsWithBase(preloads, applyBase) {
 	const withBase = {};
 	for (const [key, files] of Object.entries(preloads)) withBase[key] = files.map(applyBase);
 	return withBase;
 }
 //#endregion
-export { computeDynamicImportPreloads, computeLazyChunks, dynamicImportPreloadsWithBase };
+export { addDynamicImportPreloadAliases, computeDynamicImportPreloads, computeLazyChunks, dynamicImportPreloadsWithBase };

package/dist/utils/middleware-request-headers.d.ts

@@ -21,4 +21,5 @@ export declare function encodeMiddlewareRequestHeaders(targetHeaders: Headers, r
  */
 export declare function buildRequestHeadersFromMiddlewareResponse(baseHeaders: Headers, middlewareHeaders: MiddlewareHeaderSource): Headers | null;
 export declare function shouldKeepMiddlewareHeader(key: string): boolean;
-//#endregion
+//#endregion
+export {};

package/dist/utils/project.d.ts

@@ -58,6 +58,8 @@ export declare function findViteConfigPath(root: string): string | undefined;
 export declare function formatMissingCloudflarePluginError(options: {
   isAppRouter: boolean;
   configFile?: string;
+  /** False when configFile is not the root vite.config.* that `vinext init` updates. */
+  initUpdatesConfig?: boolean;
 }): string;
 export type ProjectInfo = {
   root: string;
@@ -78,8 +80,6 @@ export type ProjectInfo = {
   hasMDX: boolean;
   /** CodeHike is a dependency */
   hasCodeHike: boolean;
-  /** Native Node modules that need stubbing for Workers */
-  nativeModulesToStub: string[];
 };
 /** Check whether a wrangler config file exists in the given directory. */
 export declare function hasWranglerConfig(root: string): boolean;
@@ -111,4 +111,5 @@ export declare function findDir(root: string, ...candidates: string[]): string |
  * Check if the project uses App Router (has an app/ directory).
  */
 export declare function hasAppDir(root: string): boolean;
-//#endregion
+//#endregion
+export {};