vinext 1.2.1 → 1.3.1

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,18 +1,26 @@
+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[];
   }>;
   lazyChunks?: string[];
   dynamicPreloads?: Record<string, string[]>;
+  sharedChunks?: string[];
 };
 /**
  * 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()`
@@ -31,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,10 +1,33 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { isAbsoluteAssetPrefix, resolveAssetsDir } from "./asset-prefix.js";
-import { 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 { isSharedClientChunkName, manifestFileWithAssetPrefix, manifestFileWithBase } from "./manifest-paths.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
+* emitted file names so user-configured `chunkFileNames` (e.g. hash-only
+* patterns) keep their modulepreload/script tags.
+*/
+function collectSharedChunkFiles(buildManifest, applyBase) {
+	const files = /* @__PURE__ */ new Set();
+	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) {
 	const cssGraph = {};
 	for (const [key, chunk] of Object.entries(buildManifest)) {
@@ -46,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()`
@@ -73,15 +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;
 	}
-	if (!buildManifest) return metadata;
-	if (opts.includeClientEntry) metadata.cssGraph = collectCssGraph(buildManifest, (file) => manifestFileWithBase(file, opts.assetBase));
-	metadata.appBootstrapPreinitModules = collectAppBootstrapPreinitModules(buildManifest, clientEntryManifest?.appBrowserEntry, (file) => {
+	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, 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

@@ -4,6 +4,10 @@
  */
 export type BuildManifestChunk = {
   file: string;
+  /** Source module id (or virtual id) of an entry chunk. */
+  src?: string;
+  /** Rolldown chunk name, independent of the configured output file name. */
+  name?: string;
   isEntry?: boolean;
   isDynamicEntry?: boolean;
   imports?: string[];
@@ -22,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.
@@ -54,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/manifest-paths.d.ts

@@ -26,4 +26,18 @@ export declare function assetServingUrlFromBaseAnchored(value: string, basePath:
  * `<base>/<base>/` prefix is collapsed; a single prefix is left untouched.
  */
 export declare function collapseDuplicateBase(file: string, base: string): string;
+/**
+ * Whether a Rolldown chunk belongs to the shared Pages Router runtime, judged
+ * by its exact chunk name rather than its emitted file name so user-configured
+ * or hash-only `chunkFileNames` keep their modulepreload/script tags.
+ */
+export declare function isSharedClientChunkName(name: string | undefined): boolean;
+/**
+ * Reserved `ssr-manifest.json` key listing the shared runtime chunk files.
+ * Consumers that pass the on-disk manifest straight to `renderPage()` (the
+ * legacy two-call Pages build) have no registered build metadata, and file
+ * names alone can't identify these chunks. The `\0` prefix keeps it from
+ * matching any module id.
+ */
+export declare const SSR_MANIFEST_SHARED_CHUNKS_KEY = "\0vinext:shared-chunks";
 //#endregion

package/dist/utils/manifest-paths.js

@@ -62,5 +62,26 @@ function collapseDuplicateBase(file, base) {
 	const doubledPrefix = `${normalizedBase}/${normalizedBase}/`;
 	return normalizedFile.startsWith(doubledPrefix) ? normalizedFile.slice(normalizedBase.length + 1) : normalizedFile;
 }
+const SHARED_CHUNK_NAMES = /* @__PURE__ */ new Set([
+	"framework",
+	"vinext",
+	"vinext-client-entry"
+]);
+/**
+* Whether a Rolldown chunk belongs to the shared Pages Router runtime, judged
+* by its exact chunk name rather than its emitted file name so user-configured
+* or hash-only `chunkFileNames` keep their modulepreload/script tags.
+*/
+function isSharedClientChunkName(name) {
+	return name !== void 0 && SHARED_CHUNK_NAMES.has(name);
+}
+/**
+* Reserved `ssr-manifest.json` key listing the shared runtime chunk files.
+* Consumers that pass the on-disk manifest straight to `renderPage()` (the
+* legacy two-call Pages build) have no registered build metadata, and file
+* names alone can't identify these chunks. The `\0` prefix keeps it from
+* matching any module id.
+*/
+const SSR_MANIFEST_SHARED_CHUNKS_KEY = "\0vinext:shared-chunks";
 //#endregion
-export { assetServingUrlFromBaseAnchored, collapseDuplicateBase, manifestFileWithAssetPrefix, manifestFileWithBase };
+export { SSR_MANIFEST_SHARED_CHUNKS_KEY, assetServingUrlFromBaseAnchored, collapseDuplicateBase, isSharedClientChunkName, manifestFileWithAssetPrefix, manifestFileWithBase };

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/path-to-regexp.d.ts

@@ -0,0 +1,21 @@
+//#region src/utils/path-to-regexp.d.ts
+export type PathToken = string | PathKey;
+export type PathKey = {
+  name: string | number;
+  prefix: string;
+  suffix: string;
+  pattern: string;
+  modifier: string;
+};
+export type ParsePathPatternOptions = {
+  /** Characters a default param cannot contain. path-to-regexp defaults to `/#?`. */
+  delimiter?: string;
+};
+export declare function parsePathPattern(value: string, options?: ParsePathPatternOptions): PathToken[];
+export declare function normalizePathTokens(tokens: PathToken[]): PathToken[];
+/**
+ * path-to-regexp's `tokensToRegexp` with `strict: true`, without the closing
+ * `$`. Callers append the ending their Next.js matcher uses.
+ */
+export declare function pathTokensToRegExpSource(tokens: PathToken[]): string;
+//#endregion

package/dist/{server/middleware-path-to-regexp.js → utils/path-to-regexp.js}

@@ -1,4 +1,4 @@
-//#region src/server/middleware-path-to-regexp.ts
+//#region src/utils/path-to-regexp.ts
 function lexer(value) {
 	const tokens = [];
 	let index = 0;
@@ -101,11 +101,12 @@ function lexer(value) {
 	});
 	return tokens;
 }
-function parseMiddlewarePath(value) {
+function parsePathPattern(value, options = {}) {
 	const tokens = lexer(value);
 	const result = [];
 	const prefixes = "./";
-	const delimiter = "/#?";
+	const delimiter = options.delimiter ?? "/#?";
+	const delimiterClass = `[^${escapeRegex(delimiter)}]`;
 	let key = 0;
 	let index = 0;
 	let path = "";
@@ -135,8 +136,8 @@ function parseMiddlewarePath(value) {
 			const name = typeof previous === "string" ? previous : previous.name;
 			throw new TypeError(`Must have text between two parameters, missing text after "${name}"`);
 		}
-		if (!previousText || containsDelimiter(previousText)) return "[^\\/#\\?]+?";
-		return `(?:(?!${escapeRegex(previousText)})[^\\/#\\?])+?`;
+		if (!previousText || containsDelimiter(previousText)) return `${delimiterClass}+?`;
+		return `(?:(?!${escapeRegex(previousText)})${delimiterClass})+?`;
 	};
 	while (index < tokens.length) {
 		const character = tryConsume("CHAR");
@@ -192,7 +193,7 @@ function parseMiddlewarePath(value) {
 function escapeRegex(value) {
 	return value.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
 }
-function normalizeMiddlewarePathTokens(tokens) {
+function normalizePathTokens(tokens) {
 	return tokens.map((token) => {
 		if (typeof token === "object" && (token.modifier === "*" || token.modifier === "+") && token.prefix === "" && token.suffix === "") return {
 			...token,
@@ -201,8 +202,11 @@ function normalizeMiddlewarePathTokens(tokens) {
 		return token;
 	});
 }
-function middlewarePathTokensToRegExp(tokens) {
-	const delimiterRegex = `[${escapeRegex("/#?")}]`;
+/**
+* path-to-regexp's `tokensToRegexp` with `strict: true`, without the closing
+* `$`. Callers append the ending their Next.js matcher uses.
+*/
+function pathTokensToRegExpSource(tokens) {
 	let route = "^";
 	for (const token of tokens) {
 		if (typeof token === "string") {
@@ -223,8 +227,7 @@ function middlewarePathTokensToRegExp(tokens) {
 			}
 		} else route += `(?:${prefix}${suffix})${token.modifier}`;
 	}
-	route += `${delimiterRegex}?$`;
-	return new RegExp(route);
+	return route;
 }
 //#endregion
-export { middlewarePathTokensToRegExp, normalizeMiddlewarePathTokens, parseMiddlewarePath };
+export { normalizePathTokens, parsePathPattern, pathTokensToRegExpSource };

package/dist/utils/plugin-react-version.d.ts

@@ -0,0 +1,15 @@
+//#region src/utils/plugin-react-version.d.ts
+/**
+ * Resolve @vitejs/plugin-react from the project, falling back to vinext's own
+ * install when the project has none or reaches an unsupported version.
+ * Returns null when it is not installed, and throws when every copy found is
+ * unsupported.
+ */
+export declare function resolvePluginReactPath(projectRoot: string, fallbackFrom?: string): string | null;
+/**
+ * The @vitejs/plugin-react upgrade vinext init must install before vinext.
+ * A declared copy below the floor conflicts with vinext's peer range: npm stops
+ * with ERESOLVE, and pnpm installs but vinext refuses to start.
+ */
+export declare function getPluginReactUpgradeDeps(root: string): string[];
+//#endregion

package/dist/utils/plugin-react-version.js

@@ -0,0 +1,64 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { findPackageVersion, isVersionBelow } from "./react-version.js";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+//#region src/utils/plugin-react-version.ts
+const MINIMUM_PLUGIN_REACT_VERSION = [
+	5,
+	1,
+	4
+];
+function resolveFrom(from) {
+	try {
+		const resolved = createRequire(from).resolve("@vitejs/plugin-react");
+		return {
+			path: resolved,
+			version: findPackageVersion(resolved, "@vitejs/plugin-react")
+		};
+	} catch {
+		return null;
+	}
+}
+function isSupported(plugin) {
+	return plugin.version !== null && !isVersionBelow(plugin.version, MINIMUM_PLUGIN_REACT_VERSION);
+}
+/**
+* Resolve @vitejs/plugin-react from the project, falling back to vinext's own
+* install when the project has none or reaches an unsupported version.
+* Returns null when it is not installed, and throws when every copy found is
+* unsupported.
+*/
+function resolvePluginReactPath(projectRoot, fallbackFrom = import.meta.url) {
+	const project = resolveFrom(path.join(projectRoot, "package.json"));
+	if (project && isSupported(project)) return project.path;
+	const fallback = resolveFrom(fallbackFrom);
+	if (fallback && isSupported(fallback)) {
+		if (project) console.warn(`[vinext] Ignoring @vitejs/plugin-react ${project.version ?? "(unknown version)"} at ${project.path}: vinext requires ${MINIMUM_PLUGIN_REACT_VERSION.join(".")} or newer. Using ${fallback.version} instead. Add @vitejs/plugin-react to your app's devDependencies to choose the version explicitly.`);
+		return fallback.path;
+	}
+	const found = project ?? fallback;
+	if (!found) return null;
+	throw new Error(`vinext: @vitejs/plugin-react ${MINIMUM_PLUGIN_REACT_VERSION.join(".")} or newer is required (found ${found.version ?? "an unknown version"} at ${found.path}). Add @vitejs/plugin-react@^6 to your app's devDependencies.`);
+}
+/**
+* The @vitejs/plugin-react upgrade vinext init must install before vinext.
+* A declared copy below the floor conflicts with vinext's peer range: npm stops
+* with ERESOLVE, and pnpm installs but vinext refuses to start.
+*/
+function getPluginReactUpgradeDeps(root) {
+	const manifest = path.join(root, "package.json");
+	let declared;
+	try {
+		const pkg = JSON.parse(fs.readFileSync(manifest, "utf-8"));
+		declared = pkg.dependencies?.["@vitejs/plugin-react"] ?? pkg.devDependencies?.["@vitejs/plugin-react"];
+	} catch {
+		return [];
+	}
+	if (typeof declared !== "string") return [];
+	const major = /^[~^]?(\d+)(?:\.(?:\d+|[x*])){0,2}$/.exec(declared.trim())?.[1];
+	if (major !== void 0 && Number(major) < MINIMUM_PLUGIN_REACT_VERSION[0]) return ["@vitejs/plugin-react@latest"];
+	const installed = resolveFrom(manifest);
+	return installed && (!isSupported(installed) || installed.version?.includes("-")) ? ["@vitejs/plugin-react@latest"] : [];
+}
+//#endregion
+export { getPluginReactUpgradeDeps, resolvePluginReactPath };

package/dist/utils/project.d.ts

@@ -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 {};

package/dist/utils/project.js

@@ -333,6 +333,14 @@ function detectMDXFromConfig(root) {
 	}
 	return false;
 }
+/**
+* Next.js copies a set legacy `experimental.cacheComponents` over the
+* top-level key (warnOptionHasBeenMovedOutOfExperimental).
+*/
+function configEnablesCacheComponents(content) {
+	if (/\bexperimental\s*:\s*\{[^}]*\bcacheComponents\s*:\s*false\b/.test(content)) return false;
+	return /\bcacheComponents\s*:\s*true\b/.test(content);
+}
 function detectCacheComponents(root) {
 	for (const fileName of [
 		"next.config.ts",
@@ -344,7 +352,7 @@ function detectCacheComponents(root) {
 		const configPath = path.join(root, fileName);
 		if (!fs.existsSync(configPath)) continue;
 		try {
-			if (/\bcacheComponents\s*:\s*true\b/.test(fs.readFileSync(configPath, "utf-8"))) return true;
+			if (configEnablesCacheComponents(fs.readFileSync(configPath, "utf-8"))) return true;
 		} catch {}
 	}
 	return false;

package/dist/utils/public-routes.d.ts

@@ -1,3 +1,5 @@
 //#region src/utils/public-routes.d.ts
 export declare function scanPublicFileRoutes(root: string, configuredPublicDir?: string | false): string[];
+/** List the files in the public directory as `/`-prefixed relative paths. */
+export declare function scanPublicFiles(root: string, configuredPublicDir?: string | false): string[];
 //#endregion

package/dist/utils/public-routes.js

@@ -3,10 +3,14 @@ import { publicFileRouteKey } from "./public-file-path.js";
 import fs from "node:fs";
 //#region src/utils/public-routes.ts
 function scanPublicFileRoutes(root, configuredPublicDir = "public") {
+	return [...new Set(scanPublicFiles(root, configuredPublicDir).map(publicFileRouteKey))].sort();
+}
+/** List the files in the public directory as `/`-prefixed relative paths. */
+function scanPublicFiles(root, configuredPublicDir = "public") {
 	if (configuredPublicDir === false || configuredPublicDir === "") return [];
 	const publicDir = path.resolve(root, configuredPublicDir);
-	const routes = [];
-	const visitedDirs = /* @__PURE__ */ new Set();
+	const files = [];
+	const ancestorDirs = /* @__PURE__ */ new Set();
 	function walk(dir) {
 		let realDir;
 		try {
@@ -14,8 +18,15 @@ function scanPublicFileRoutes(root, configuredPublicDir = "public") {
 		} catch {
 			return;
 		}
-		if (visitedDirs.has(realDir)) return;
-		visitedDirs.add(realDir);
+		if (ancestorDirs.has(realDir)) return;
+		ancestorDirs.add(realDir);
+		try {
+			walkEntries(dir);
+		} finally {
+			ancestorDirs.delete(realDir);
+		}
+	}
+	function walkEntries(dir) {
 		const entries = fs.readdirSync(dir, { withFileTypes: true });
 		for (const entry of entries) {
 			const fullPath = path.join(dir, entry.name);
@@ -37,13 +48,13 @@ function scanPublicFileRoutes(root, configuredPublicDir = "public") {
 				if (!stat.isFile()) continue;
 			} else if (!entry.isFile()) continue;
 			const relativePath = path.relative(publicDir, fullPath);
-			routes.push(publicFileRouteKey("/" + relativePath));
+			files.push("/" + relativePath);
 		}
 	}
 	if (fs.existsSync(publicDir)) try {
 		walk(publicDir);
 	} catch {}
-	return [...new Set(routes)].sort();
+	return files;
 }
 //#endregion
-export { scanPublicFileRoutes };
+export { scanPublicFileRoutes, scanPublicFiles };

package/dist/utils/query.d.ts

@@ -51,4 +51,5 @@ export declare function mergeRewriteQuery(originalUrl: string, rewriteUrl: strin
  * and fragment identifier.
  */
 export declare function appendSearchParamsToUrl(url: string, params: Iterable<[string, string]>): string;
-//#endregion
+//#endregion
+export {};