vinext 1.2.1 → 1.3.0

package/dist/build/nitro-public-files.d.ts

@@ -0,0 +1,24 @@
+//#region src/build/nitro-public-files.d.ts
+/** The Nitro options this integration reads and updates. */
+export type NitroPublicFilesOptions = {
+  dev?: boolean;
+  preset?: string;
+  baseURL?: string;
+  serveStatic?: boolean | string;
+  plugins?: string[];
+  virtual?: Record<string, string | (() => string)>;
+  output?: {
+    publicDir?: string;
+  };
+};
+/**
+ * Register vinext's Nitro runtime plugin on presets whose server serves the
+ * static output, so requests for public files run through vinext, including
+ * its middleware, and vinext can serve the public files its router resolves.
+ *
+ * Nitro serves the static output from its root, so this applies only when
+ * Nitro's `baseURL` is the root; vinext applies its own `basePath`. Returns
+ * whether the plugin is registered.
+ */
+export declare function registerNitroPublicFiles(options: NitroPublicFilesOptions, pluginModule: string, getPublicFiles: () => string[]): boolean;
+//#endregion

package/dist/build/nitro-public-files.js

@@ -0,0 +1,60 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import fs from "node:fs";
+//#region src/build/nitro-public-files.ts
+const NITRO_PUBLIC_FILES_PLUGIN = "#vinext/nitro-public-files";
+const CDN_STATIC_PRESETS = /* @__PURE__ */ new Set(["aws-amplify"]);
+const COMPRESSED_EXTENSIONS = [
+	".br",
+	".gz",
+	".zst"
+];
+function toNitroAssetId(relativePath) {
+	let decoded = relativePath;
+	try {
+		decoded = decodeURIComponent(relativePath);
+	} catch {}
+	return "/" + decoded.replace(/^\.?\//, "");
+}
+/**
+* List the static files Nitro serves for the files in `public/`, keyed as
+* Nitro's static handler keys them: each file that Nitro copied to its output
+* directory, and the compressed copies of it that Nitro wrote there.
+*/
+function listNitroPublicAssets(publicFiles, outputPublicDir) {
+	if (!outputPublicDir) return [];
+	const assets = [];
+	for (const file of publicFiles) {
+		const relativePath = file.slice(1);
+		for (const extension of ["", ...COMPRESSED_EXTENSIONS]) if (fs.statSync(path.join(outputPublicDir, relativePath + extension), { throwIfNoEntry: false })?.isFile()) assets.push(toNitroAssetId(relativePath + extension));
+	}
+	return [...new Set(assets)].sort();
+}
+/**
+* Register vinext's Nitro runtime plugin on presets whose server serves the
+* static output, so requests for public files run through vinext, including
+* its middleware, and vinext can serve the public files its router resolves.
+*
+* Nitro serves the static output from its root, so this applies only when
+* Nitro's `baseURL` is the root; vinext applies its own `basePath`. Returns
+* whether the plugin is registered.
+*/
+function registerNitroPublicFiles(options, pluginModule, getPublicFiles) {
+	if (options.dev || !options.serveStatic) return false;
+	if (options.preset && CDN_STATIC_PRESETS.has(options.preset.replaceAll("_", "-"))) return false;
+	if ((options.baseURL ?? "/") !== "/") return false;
+	options.virtual ??= {};
+	options.virtual[NITRO_PUBLIC_FILES_PLUGIN] = () => [
+		"import { fetchViteEnv } from \"nitro/vite/runtime\";",
+		`import { createNitroPublicFilesPlugin } from ${JSON.stringify(pluginModule)};`,
+		"export default createNitroPublicFilesPlugin({",
+		`  publicAssets: ${JSON.stringify(listNitroPublicAssets(getPublicFiles(), options.output?.publicDir))},`,
+		"  fetchApp: (request) => fetchViteEnv(\"ssr\", request),",
+		"});",
+		""
+	].join("\n");
+	options.plugins ??= [];
+	if (!options.plugins.includes(NITRO_PUBLIC_FILES_PLUGIN)) options.plugins.push(NITRO_PUBLIC_FILES_PLUGIN);
+	return true;
+}
+//#endregion
+export { registerNitroPublicFiles };

package/dist/build/pages-client-assets-module.js

@@ -6,7 +6,7 @@ import fs from "node:fs";
 //#region src/build/pages-client-assets-module.ts
 const PAGES_CLIENT_ASSETS_MODULE = "vinext-client-assets.js";
 function buildPagesClientAssetsModule(assets) {
-	const prepared = assets.ssrManifest ? {
+	const prepared = assets.ssrManifest && !assets.sharedChunks ? {
 		...assets,
 		sharedChunks: getSharedChunkFiles(assets.ssrManifest)
 	} : assets;

package/dist/build/prerender-paths.js

@@ -9,7 +9,7 @@ import { loadNextConfig, resolveNextConfig } from "../config/next-config.js";
 import { appRouteHasMainTreeLoadingBoundary, appRouter, matchAppRoute } from "../routing/app-router.js";
 import { apiRouter, matchRoute, pagesRouter } from "../routing/pages-router.js";
 import { matchesMiddlewarePathname } from "../server/middleware-matcher.js";
-import { extractLocaleFromUrl, normalizeDefaultLocalePathname } from "../server/pages-i18n.js";
+import { extractLocaleFromUrl, normalizeDefaultLocalePathname, shouldRestoreLocaleRootTrailingSlash } from "../server/pages-i18n.js";
 import { classifyAppRoute, classifyAppRouteHandler, classifyPagesRoute, extractExportConstString, extractMiddlewareMatcherConfig, getAppRouteRenderEntryPath } from "./report.js";
 import { normalizeStaticPathname, normalizeStaticPathsEntry } from "../routing/route-pattern.js";
 import { buildPagesDataHref } from "../shims/internal/pages-data-url.js";
@@ -578,7 +578,10 @@ async function resolveAppWarmPaths(options) {
 function cachePolicyRuleMatchesWarmPath(pathname, rule, config) {
 	const canonicalPathname = normalizePathTrailingSlash(pathname, config.trailingSlash);
 	return [void 0, ...config.i18n?.domains?.map((domain) => domain.domain) ?? []].some((hostname) => {
-		const matchPathname = normalizeDefaultLocalePathname(canonicalPathname, config.i18n, { hostname });
+		const matchPathname = normalizeDefaultLocalePathname(canonicalPathname, config.i18n, {
+			hostname,
+			restoreRootTrailingSlash: shouldRestoreLocaleRootTrailingSlash(canonicalPathname, config)
+		});
 		let sourceMatched = false;
 		matchHeaders(matchPathname, [rule], {
 			cookies: {},

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

@@ -0,0 +1,23 @@
+//#region src/build/server-actions-encryption-key.d.ts
+type LoadEncryptionKeyOptions = {
+  root: string;
+  isBuild: boolean;
+  /** Defaults to `process.env.NEXT_SERVER_ACTIONS_ENCRYPTION_KEY`. */
+  providedKey?: string;
+  now?: number;
+  /** Defaults to Docker detection; Docker filesystems are likely ephemeral. */
+  hasPersistentStorage?: boolean;
+};
+/**
+ * Return NEXT_SERVER_ACTIONS_ENCRYPTION_KEY when set, otherwise a generated
+ * key that is cached in `.vinext/cache` for 14 days.
+ */
+export declare function loadOrGenerateServerActionsEncryptionKey(options: LoadEncryptionKeyOptions): string;
+/**
+ * The cached key lives inside the project root, which the dev server serves.
+ * Return the `server.fs.deny` entries that keep it private, preserving Vite's
+ * defaults and any configured entries. Like `.env` files, it is only exposed
+ * when `server.fs.strict` is false, which turns off Vite's file restrictions.
+ */
+export declare function getServerActionsKeyCacheFsDeny(configuredDeny: string[] | undefined): string[];
+//#endregion

package/dist/build/server-actions-encryption-key.js

@@ -0,0 +1,101 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import fs from "node:fs";
+import { randomBytes } from "node:crypto";
+//#region src/build/server-actions-encryption-key.ts
+/**
+* Ported from Next.js: packages/next/src/server/app-render/encryption-utils-server.ts
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/server/app-render/encryption-utils-server.ts
+*
+* Next salts server-reference IDs with this key, so keeping it stable keeps
+* client chunk names stable across rebuilds of identical source. Next caches
+* a generated key under `<distDir>/cache` for builds and `<distDir>/dev/cache`
+* for dev; vinext uses `<root>/.vinext/cache` and `<root>/.vinext/dev/cache`
+* because `dist/` is wiped by every build.
+*/
+const CONFIG_FILE = ".rscinfo";
+const ENCRYPTION_KEY = "encryption.key";
+const ENCRYPTION_EXPIRE_AT = "encryption.expire_at";
+const EXPIRATION = 12096e5;
+const VITE_DEFAULT_FS_DENY = [
+	".env",
+	".env.*",
+	"*.{crt,pem,key,p12,pfx,cer,der}",
+	".npmrc",
+	".yarnrc.yml",
+	"**/.git/**"
+];
+const KEY_CACHE_FS_DENY = `**/.vinext/**/${CONFIG_FILE}`;
+let isDockerResult;
+function isDocker() {
+	if (isDockerResult === void 0) {
+		let hasDockerEnv = false;
+		try {
+			fs.statSync("/.dockerenv");
+			hasDockerEnv = true;
+		} catch {}
+		let hasDockerCGroup = false;
+		if (!hasDockerEnv) try {
+			hasDockerCGroup = fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+		} catch {}
+		isDockerResult = hasDockerEnv || hasDockerCGroup;
+	}
+	return isDockerResult;
+}
+function readCachedKey(configPath, isBuild, providedKey, now) {
+	if (!fs.existsSync(configPath)) return void 0;
+	try {
+		const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+		if (typeof config !== "object" || config === null) return void 0;
+		const cachedKey = config[ENCRYPTION_KEY];
+		const expireAt = config[ENCRYPTION_EXPIRE_AT];
+		if (typeof cachedKey !== "string" || typeof expireAt !== "number") return void 0;
+		if (isBuild && expireAt < now) return void 0;
+		if (cachedKey && providedKey && cachedKey !== providedKey) return void 0;
+		return cachedKey;
+	} catch {
+		return;
+	}
+}
+/**
+* Return NEXT_SERVER_ACTIONS_ENCRYPTION_KEY when set, otherwise a generated
+* key that is cached in `.vinext/cache` for 14 days.
+*/
+function loadOrGenerateServerActionsEncryptionKey(options) {
+	const providedKey = "providedKey" in options ? options.providedKey : process.env.NEXT_SERVER_ACTIONS_ENCRYPTION_KEY;
+	const generateKey = () => providedKey || randomBytes(32).toString("base64");
+	if (!(options.hasPersistentStorage ?? !isDocker())) return generateKey();
+	const now = options.now ?? Date.now();
+	const cacheDir = options.isBuild ? path.join(options.root, ".vinext", "cache") : path.join(options.root, ".vinext", "dev", "cache");
+	const configPath = path.join(cacheDir, CONFIG_FILE);
+	const cachedKey = readCachedKey(configPath, options.isBuild, providedKey, now);
+	if (cachedKey !== void 0) {
+		restrictKeyCacheMode(configPath);
+		return cachedKey;
+	}
+	const key = generateKey();
+	try {
+		fs.mkdirSync(cacheDir, { recursive: true });
+		fs.writeFileSync(configPath, JSON.stringify({
+			[ENCRYPTION_KEY]: key,
+			[ENCRYPTION_EXPIRE_AT]: now + EXPIRATION
+		}), { mode: 384 });
+		restrictKeyCacheMode(configPath);
+	} catch {}
+	return key;
+}
+function restrictKeyCacheMode(configPath) {
+	try {
+		fs.chmodSync(configPath, 384);
+	} catch {}
+}
+/**
+* The cached key lives inside the project root, which the dev server serves.
+* Return the `server.fs.deny` entries that keep it private, preserving Vite's
+* defaults and any configured entries. Like `.env` files, it is only exposed
+* when `server.fs.strict` is false, which turns off Vite's file restrictions.
+*/
+function getServerActionsKeyCacheFsDeny(configuredDeny) {
+	return configuredDeny ? [KEY_CACHE_FS_DENY] : [...VITE_DEFAULT_FS_DENY, KEY_CACHE_FS_DENY];
+}
+//#endregion
+export { getServerActionsKeyCacheFsDeny, loadOrGenerateServerActionsEncryptionKey };

package/dist/build/ssr-manifest.d.ts

@@ -2,6 +2,9 @@
 export type BundleBackfillChunk = {
   type: "chunk";
   fileName: string;
+  name?: string;
+  isEntry?: boolean;
+  facadeModuleId?: string | null;
   imports?: string[];
   modules?: Record<string, unknown>;
   viteMetadata?: {

package/dist/build/ssr-manifest.js

@@ -1,7 +1,13 @@
 import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
-import { collapseDuplicateBase, manifestFileWithBase } from "../utils/manifest-paths.js";
+import { SSR_MANIFEST_SHARED_CHUNKS_KEY, collapseDuplicateBase, isSharedClientChunkName, manifestFileWithBase } from "../utils/manifest-paths.js";
 import fs from "node:fs";
 //#region src/build/ssr-manifest.ts
+const PAGES_CLIENT_ENTRY_ID = "virtual:vinext-client-entry";
+function isPagesClientEntryFacade(facadeModuleId) {
+	if (!facadeModuleId) return false;
+	const id = toSlash(facadeModuleId.startsWith("\0") ? facadeModuleId.slice(1) : facadeModuleId);
+	return id === PAGES_CLIENT_ENTRY_ID || id.endsWith(`/${PAGES_CLIENT_ENTRY_ID}`);
+}
 /**
 * Realpath with NATIVE separators (backslashes on Windows). Callers apply
 * `toSlash` where the result becomes a module id / manifest key.
@@ -50,6 +56,7 @@ function normalizeManifestModuleId(moduleId, root) {
 }
 function augmentSsrManifestFromBundle(ssrManifest, bundle, root, base = "/") {
 	const nextManifest = {};
+	const sharedChunkFiles = /* @__PURE__ */ new Set();
 	for (const [key, files] of Object.entries(ssrManifest)) {
 		const normalizedKey = normalizeManifestModuleId(key, root);
 		if (!nextManifest[normalizedKey]) nextManifest[normalizedKey] = /* @__PURE__ */ new Set();
@@ -58,6 +65,7 @@ function augmentSsrManifestFromBundle(ssrManifest, bundle, root, base = "/") {
 	for (const item of Object.values(bundle)) {
 		if (item.type !== "chunk") continue;
 		const chunk = item;
+		if (chunk.fileName.endsWith(".js") && (isSharedClientChunkName(chunk.name) || chunk.isEntry && isPagesClientEntryFacade(chunk.facadeModuleId))) sharedChunkFiles.add(manifestFileWithBase(chunk.fileName, base));
 		const files = /* @__PURE__ */ new Set();
 		files.add(manifestFileWithBase(chunk.fileName, base));
 		for (const importedFile of chunk.imports ?? []) files.add(manifestFileWithBase(importedFile, base));
@@ -71,6 +79,7 @@ function augmentSsrManifestFromBundle(ssrManifest, bundle, root, base = "/") {
 			for (const file of files) nextManifest[key].add(file);
 		}
 	}
+	if (sharedChunkFiles.size > 0) nextManifest[SSR_MANIFEST_SHARED_CHUNKS_KEY] = sharedChunkFiles;
 	return Object.fromEntries(Object.entries(nextManifest).map(([key, files]) => [key, [...files]]));
 }
 //#endregion

package/dist/client/client-rewrite-params.d.ts

@@ -0,0 +1,9 @@
+//#region src/client/client-rewrite-params.d.ts
+/**
+ * Whether a rewrite to `destination` appends the source `params` to its
+ * query. Next.js does that when the destination's path, host and hash use
+ * none of them, for each param its query does not already name; the Pages
+ * router's sync rewrite path does not, so it defers these rewrites.
+ */
+export declare function clientRewriteAppendsParams(destination: string, params: Record<string, string>): boolean;
+//#endregion

package/dist/client/client-rewrite-params.js

@@ -0,0 +1,20 @@
+//#region src/client/client-rewrite-params.ts
+/**
+* Whether a rewrite to `destination` appends the source `params` to its
+* query. Next.js does that when the destination's path, host and hash use
+* none of them, for each param its query does not already name; the Pages
+* router's sync rewrite path does not, so it defers these rewrites.
+*/
+function clientRewriteAppendsParams(destination, params) {
+	const keys = Object.keys(params).filter((key) => key !== "nextInternalLocale");
+	if (keys.length === 0) return false;
+	const hashIndex = destination.indexOf("#");
+	const beforeHash = hashIndex === -1 ? destination : destination.slice(0, hashIndex);
+	const queryIndex = beforeHash.indexOf("?");
+	const withoutQuery = (queryIndex === -1 ? beforeHash : beforeHash.slice(0, queryIndex)) + (hashIndex === -1 ? "" : destination.slice(hashIndex));
+	if (keys.some((key) => new RegExp(`:${key}(?![A-Za-z0-9_])`).test(withoutQuery))) return false;
+	const queryKeys = new Set(queryIndex === -1 ? [] : new URLSearchParams(beforeHash.slice(queryIndex + 1)).keys());
+	return keys.some((key) => !queryKeys.has(key));
+}
+//#endregion
+export { clientRewriteAppendsParams };

package/dist/client/dev-error-overlay.js

@@ -26,11 +26,12 @@ function installDevErrorOverlay() {
 	installed = true;
 	window.addEventListener("error", (event) => {
 		const err = event.error;
+		if (!err) return;
 		if (isNavigationSignalError(err)) return;
 		if (err instanceof Error) {
 			if (alreadyReported(err)) return;
 			reportDevError(err, { source: "window-error" });
-		} else if (event.message) reportDevError(new Error(event.message), { source: "window-error" });
+		} else reportDevError(event.message ? new Error(event.message) : err, { source: "window-error" });
 	});
 	window.addEventListener("unhandledrejection", (event) => {
 		const reason = event.reason;

package/dist/client/navigation-runtime.d.ts

@@ -1,4 +1,4 @@
-import { RouteManifest } from "../routing/app-route-graph.js";
+import { BrowserRouteManifest, BrowserRouteManifestWire } from "../routing/browser-route-manifest.js";
 import { AppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
 //#region src/client/navigation-runtime.d.ts
 type NavigationRuntimeSnapshot = {
@@ -7,6 +7,8 @@ type NavigationRuntimeSnapshot = {
 };
 export type NavigationRuntimeRscChunk = string | [3, string];
 export type NavigationRuntimeRscBootstrap = {
+  /** The server's App Router RSC compatibility ID for this page. */
+  compatibilityId?: string;
   done?: boolean;
   dynamicStaleTimeSeconds?: number;
   initialCacheKind?: "dynamic" | "static";
@@ -68,9 +70,15 @@ export type NavigationRuntimeFunctions = {
    * committing writes its URL first, as Next.js does from an insertion effect.
    */
   flushCommittingNavigationUrl?: () => void;
+  /**
+   * Starts loading the browser RouteManifest chunk, or joins the load in
+   * progress. Returns null once the manifest is registered. Created by
+   * createNavigationRuntimeRouteManifestLoader.
+   */
+  loadRouteManifest?: () => Promise<boolean> | null;
 };
 export type NavigationRuntimeBootstrap = {
-  routeManifest: RouteManifest | null;
+  routeManifest: BrowserRouteManifest | null;
   rsc: NavigationRuntimeRscBootstrap | undefined;
 };
 export type NavigationRuntime = {
@@ -82,6 +90,21 @@ export declare function getNavigationRuntime(): NavigationRuntime | null;
 export declare function registerNavigationRuntimeBootstrap(bootstrap: Partial<NavigationRuntimeBootstrap>): NavigationRuntime;
 export declare function registerNavigationRuntimeFunctions(functions: Partial<NavigationRuntimeFunctions>): NavigationRuntime;
 export declare function ensureNavigationRuntimeRscBootstrap(): NavigationRuntimeRscBootstrap;
+/**
+ * The browser entry does not inline the RouteManifest: the manifest grows with
+ * every route of the app, so it lives in its own chunk that loads alongside
+ * hydration. The navigation planner needs it to classify commits (root layout
+ * changes, intercepted payloads, preserved slots), so navigations, commits and
+ * prefetches that read it wait for this load first.
+ */
+export declare function createNavigationRuntimeRouteManifestLoader(importManifest: () => Promise<{
+  default: BrowserRouteManifestWire | null;
+}>): () => Promise<boolean> | null;
+/**
+ * Starts or joins the RouteManifest load. Resolves whether it loaded, and
+ * returns null once it has (or when no App Router runtime registered a loader).
+ */
+export declare function loadNavigationRuntimeRouteManifest(): Promise<boolean> | null;
 export declare function hasAppNavigationRuntime(): boolean;
 /**
  * True when the App Router has installed its runtime bootstrap on `window`,

package/dist/client/navigation-runtime.js

@@ -1,20 +1,15 @@
 import { isUnknownRecord } from "../utils/record.js";
+import { decodeBrowserRouteManifest } from "../routing/browser-route-manifest.js";
 import { NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION } from "./browser-globals.js";
 //#region src/client/navigation-runtime.ts
 const NAVIGATION_RUNTIME_KEY = Symbol.for(NAVIGATION_RUNTIME_SYMBOL_DESCRIPTION);
 const ROUTE_MANIFEST_SEGMENT_GRAPH_MAP_KEYS = [
-	"boundaries",
-	"defaults",
 	"interceptions",
 	"interceptionsBySlotId",
 	"layouts",
-	"pages",
 	"rootBoundaries",
-	"routeHandlers",
 	"routes",
-	"slotBindings",
-	"slots",
-	"templates"
+	"slotBindings"
 ];
 function createNavigationRuntime() {
 	return {
@@ -31,7 +26,7 @@ function readRuntimeWindow() {
 }
 function isNavigationRuntimeFunctions(value) {
 	if (!isUnknownRecord(value)) return false;
-	return isOptionalRuntimeFunction(Reflect.get(value, "clearNavigationCaches")) && isOptionalRuntimeFunction(Reflect.get(value, "commitHashNavigation")) && isOptionalRuntimeFunction(Reflect.get(value, "navigateExternal")) && isOptionalRuntimeFunction(Reflect.get(value, "navigate")) && isOptionalRuntimeFunction(Reflect.get(value, "getPrefetchRouterState")) && isOptionalRuntimeFunction(Reflect.get(value, "notifyLinkNavigationStart")) && isOptionalRuntimeFunction(Reflect.get(value, "pingVisibleLinks")) && isOptionalRuntimeFunction(Reflect.get(value, "preparePrefetchResponse")) && isOptionalRuntimeFunction(Reflect.get(value, "claimCurrentHistoryTreeSnapshot")) && isOptionalRuntimeFunction(Reflect.get(value, "commitAppOwnedHistoryStateWrite")) && isOptionalRuntimeFunction(Reflect.get(value, "discardPendingNavigation")) && isOptionalRuntimeFunction(Reflect.get(value, "flushCommittingNavigationUrl"));
+	return isOptionalRuntimeFunction(Reflect.get(value, "clearNavigationCaches")) && isOptionalRuntimeFunction(Reflect.get(value, "commitHashNavigation")) && isOptionalRuntimeFunction(Reflect.get(value, "navigateExternal")) && isOptionalRuntimeFunction(Reflect.get(value, "navigate")) && isOptionalRuntimeFunction(Reflect.get(value, "getPrefetchRouterState")) && isOptionalRuntimeFunction(Reflect.get(value, "notifyLinkNavigationStart")) && isOptionalRuntimeFunction(Reflect.get(value, "pingVisibleLinks")) && isOptionalRuntimeFunction(Reflect.get(value, "preparePrefetchResponse")) && isOptionalRuntimeFunction(Reflect.get(value, "claimCurrentHistoryTreeSnapshot")) && isOptionalRuntimeFunction(Reflect.get(value, "commitAppOwnedHistoryStateWrite")) && isOptionalRuntimeFunction(Reflect.get(value, "discardPendingNavigation")) && isOptionalRuntimeFunction(Reflect.get(value, "flushCommittingNavigationUrl")) && isOptionalRuntimeFunction(Reflect.get(value, "loadRouteManifest"));
 }
 function isNavigationRuntimeRscChunk(value) {
 	if (typeof value === "string") return true;
@@ -49,6 +44,7 @@ function isNavigationRuntimeParams(value) {
 }
 function isNavigationRuntimeRscBootstrap(value) {
 	if (!isUnknownRecord(value)) return false;
+	const compatibilityId = Reflect.get(value, "compatibilityId");
 	const done = Reflect.get(value, "done");
 	const dynamicStaleTimeSeconds = Reflect.get(value, "dynamicStaleTimeSeconds");
 	const initialCacheKind = Reflect.get(value, "initialCacheKind");
@@ -58,7 +54,7 @@ function isNavigationRuntimeRscBootstrap(value) {
 	const renderedSearch = Reflect.get(value, "renderedSearch");
 	const rsc = Reflect.get(value, "rsc");
 	const staleTimeSeconds = Reflect.get(value, "staleTimeSeconds");
-	return (done === void 0 || typeof done === "boolean") && isOptionalStaleTimeSeconds(dynamicStaleTimeSeconds) && (initialCacheKind === void 0 || initialCacheKind === "dynamic" || initialCacheKind === "static") && (searchParamsFromBrowser === void 0 || typeof searchParamsFromBrowser === "boolean") && (nav === void 0 || isNavigationRuntimeSnapshot(nav)) && (params === void 0 || isNavigationRuntimeParams(params)) && (renderedSearch === void 0 || typeof renderedSearch === "string") && Array.isArray(rsc) && rsc.every(isNavigationRuntimeRscChunk) && isOptionalStaleTimeSeconds(staleTimeSeconds);
+	return (compatibilityId === void 0 || typeof compatibilityId === "string") && (done === void 0 || typeof done === "boolean") && isOptionalStaleTimeSeconds(dynamicStaleTimeSeconds) && (initialCacheKind === void 0 || initialCacheKind === "dynamic" || initialCacheKind === "static") && (searchParamsFromBrowser === void 0 || typeof searchParamsFromBrowser === "boolean") && (nav === void 0 || isNavigationRuntimeSnapshot(nav)) && (params === void 0 || isNavigationRuntimeParams(params)) && (renderedSearch === void 0 || typeof renderedSearch === "string") && Array.isArray(rsc) && rsc.every(isNavigationRuntimeRscChunk) && isOptionalStaleTimeSeconds(staleTimeSeconds);
 }
 function isOptionalStaleTimeSeconds(value) {
 	return value === void 0 || typeof value === "number" && Number.isFinite(value) && value >= 0;
@@ -71,7 +67,7 @@ function isNullableString(value) {
 }
 function isNavigationRuntimeInterception(value) {
 	if (!isUnknownRecord(value)) return false;
-	return typeof value.id === "string" && typeof value.sourcePattern === "string" && isReadonlyStringArray(value.sourcePatternParts) && typeof value.targetPattern === "string" && isReadonlyStringArray(value.targetPatternParts) && typeof value.slotId === "string" && isNullableString(value.ownerLayoutId) && isNullableString(value.interceptingRouteId) && isNullableString(value.targetRouteId);
+	return typeof value.id === "string" && isReadonlyStringArray(value.sourcePatternParts) && isReadonlyStringArray(value.targetPatternParts) && typeof value.slotId === "string" && isNullableString(value.ownerLayoutId) && isNullableString(value.targetRouteId);
 }
 function isNavigationRuntimeInterceptionArray(value) {
 	return Array.isArray(value) && value.every(isNavigationRuntimeInterception);
@@ -150,6 +146,41 @@ function ensureNavigationRuntimeRscBootstrapForRuntime(runtime) {
 	}
 	return rscBootstrap;
 }
+/**
+* The browser entry does not inline the RouteManifest: the manifest grows with
+* every route of the app, so it lives in its own chunk that loads alongside
+* hydration. The navigation planner needs it to classify commits (root layout
+* changes, intercepted payloads, preserved slots), so navigations, commits and
+* prefetches that read it wait for this load first.
+*/
+function createNavigationRuntimeRouteManifestLoader(importManifest) {
+	let loaded = false;
+	let reportedFailure = false;
+	let pending = null;
+	return () => {
+		if (loaded) return null;
+		pending ??= importManifest().then(({ default: wire }) => {
+			registerNavigationRuntimeBootstrap({ routeManifest: wire === null ? null : decodeBrowserRouteManifest(wire) });
+			loaded = true;
+			return true;
+		}).catch((error) => {
+			pending = null;
+			if (!reportedFailure) {
+				reportedFailure = true;
+				console.error("[vinext] Failed to load the App Router route manifest:", error);
+			}
+			return false;
+		});
+		return pending;
+	};
+}
+/**
+* Starts or joins the RouteManifest load. Resolves whether it loaded, and
+* returns null once it has (or when no App Router runtime registered a loader).
+*/
+function loadNavigationRuntimeRouteManifest() {
+	return getNavigationRuntime()?.functions.loadRouteManifest?.() ?? null;
+}
 function hasAppNavigationRuntime() {
 	return typeof getNavigationRuntime()?.functions.navigate === "function";
 }
@@ -169,4 +200,4 @@ function hasAppNavigationRuntimeBootstrap() {
 	return getNavigationRuntime() !== null;
 }
 //#endregion
-export { NAVIGATION_RUNTIME_KEY, ensureNavigationRuntimeRscBootstrap, getNavigationRuntime, hasAppNavigationRuntime, hasAppNavigationRuntimeBootstrap, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions };
+export { NAVIGATION_RUNTIME_KEY, createNavigationRuntimeRouteManifestLoader, ensureNavigationRuntimeRscBootstrap, getNavigationRuntime, hasAppNavigationRuntime, hasAppNavigationRuntimeBootstrap, loadNavigationRuntimeRouteManifest, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions };

package/dist/client/vinext-next-data.d.ts

@@ -21,7 +21,6 @@ export type VinextLinkPrefetchRoute = {
  */
 export type VinextPagesLinkPrefetchRoute = {
   canPrefetchLoadingShell: false;
-  documentOnly?: boolean;
   isDynamic: boolean;
   patternParts: string[];
   requiresDynamicNavigationRequest?: boolean;

package/dist/config/config-matchers.d.ts

@@ -2,34 +2,8 @@ import { HasCondition, NextHeader, NextI18nConfig, NextRedirect, NextRewrite } f
 import { RequestContext, normalizeHost, parseCookies, requestContextFromRequest } from "./request-context.js";
 import { RedirectDestinationQueryPart } from "./destination-params.js";
 import { isExternalUrl } from "../utils/external-url.js";
+import { configSourceError, matchConfigPattern } from "./config-source.js";
 //#region src/config/config-matchers.d.ts
-/**
- * Detect regex patterns vulnerable to catastrophic backtracking (ReDoS).
- *
- * Uses the same deterministic structural analysis as middleware matcher
- * validation. Nested bounded repetition is accepted only when its repeated
- * language has fixed width and unambiguous branches; a fixed outer count can
- * otherwise still cause polynomially catastrophic backtracking on long near
- * misses.
- *
- * Returns true if the pattern appears safe, false if it's potentially dangerous.
- */
-export declare function isSafeRegex(pattern: string, flags?: string): boolean;
-/**
- * Compile a regex pattern safely. Returns the compiled RegExp or null if the
- * pattern is invalid or vulnerable to ReDoS.
- *
- * Logs a warning when a pattern is rejected so developers can fix their config.
- */
-export declare function safeRegExp(pattern: string, flags?: string): RegExp | null;
-/**
- * Convert a Next.js header/rewrite/redirect source pattern into a regex string.
- *
- * Regex groups in the source (e.g. `(\d+)`) are extracted first, the remaining
- * text is escaped/converted in a **single pass** (avoiding chained `.replace()`
- * which CodeQL flags as incomplete sanitization), then groups are restored.
- */
-export declare function escapeHeaderSource(source: string): string;
 /**
  * basePath gating state passed alongside the pathname to every matcher.
  *
@@ -75,7 +49,6 @@ export declare function applyMiddlewareRequestHeaders(middlewareHeaders: Record<
   postMwReqCtx: RequestContext;
 };
 export declare function checkHasConditions(has: HasCondition[] | undefined, missing: HasCondition[] | undefined, ctx: RequestContext): boolean;
-export declare function matchConfigPattern(pathname: string, pattern: string): Record<string, string> | null;
 /**
  * A matched config redirect. `destinationQuery` holds the destination query's
  * parts, split before params were substituted, for merging the request query.
@@ -220,17 +193,19 @@ export declare function matchHeaders(pathname: string, headers: NextHeader[], ct
  *     starts with `/:nextInternalLocale(en|sv|nl)` so that locale-prefixed
  *     URLs match. For redirects only, a second variant prefixed with
  *     `/${defaultLocale}` is also emitted, matching Next.js exactly.
- *   - **Vinext divergence**: we ALSO retain the original (unprefixed) source
- *     so that requests for the default locale that arrive without a prefix
- *     still match. Next.js solves this upstream by path-normalising every
- *     incoming default-locale request to include the prefix
- *     (`resolve-routes.ts` lines ~251-263); vinext currently does that
- *     normalisation only inside the pages-server-entry route matcher, so
- *     the rewrite/redirect matcher would otherwise miss unprefixed paths.
- *     Keeping the unprefixed variant gives functionally identical behaviour
- *     without requiring a server-wide path normalisation pass. The original
- *     source is appended LAST so the locale-aware variants win when both
- *     forms could match.
+ *   - Headers get only that variant, exactly like Next.js. Every header
+ *     matcher caller splices the (domain-aware) default locale into
+ *     unprefixed request paths first (`normalizeDefaultLocalePathname`,
+ *     mirroring `resolve-routes.ts`), so `/about` is matched as `/en/about`.
+ *     `/_next/*` paths are left unprefixed and therefore only match
+ *     `locale: false` rules, as in Next.js.
+ *   - **Vinext divergence (redirects/rewrites only)**: we ALSO retain the
+ *     original (unprefixed) source, appended LAST so the locale-aware
+ *     variants win when both forms could match. Their callers normalise
+ *     default-locale paths too, so this is a legacy fallback. Headers never
+ *     get it: it would apply rules Next.js skips (`/((?!api).*)` would match
+ *     `/fr/api/x` as `fr/api/x`), and default-locale requests would match
+ *     both variants, appending additive headers such as `Set-Cookie` twice.
  *
  * Destinations that are local (start with `/`) are similarly rewritten with
  * `/:nextInternalLocale` for the locale-capture variant so the locale
@@ -243,4 +218,4 @@ export declare function applyLocaleToRoutes<T extends NextRedirect | NextRewrite
   trailingSlash?: boolean;
 }): T[];
 //#endregion
-export { type RequestContext, isExternalUrl, normalizeHost, parseCookies, requestContextFromRequest };
+export { type RequestContext, configSourceError, isExternalUrl, matchConfigPattern, normalizeHost, parseCookies, requestContextFromRequest };