vinext 1.2.0 → 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/output-root-externals.d.ts

@@ -0,0 +1,21 @@
+import MagicString from "magic-string";
+//#region src/build/output-root-externals.d.ts
+/**
+ * Rewrite external virtual ids into imports of files that live at a fixed
+ * place relative to the output root.
+ *
+ * Some server modules (the cacheability manifest, the pregenerated concrete
+ * paths, the Pages client assets) are written beside the server entry, and
+ * deploy steps can rewrite them after the build. Rolldown leaves a relative
+ * external specifier exactly as written, but it can move the importing module
+ * into any chunk, for example a shared chunk under `_next/static/` when the
+ * entry becomes a facade. Keeping the virtual id external and resolving it
+ * against each chunk's own location keeps the import pointing at the file.
+ *
+ * `targets` maps each external id to its file path relative to the output root.
+ */
+export declare function rewriteOutputRootExternals(code: string, chunkFileName: string, targets: ReadonlyMap<string, string>): {
+  code: string;
+  map: ReturnType<MagicString["generateMap"]>;
+} | null;
+//#endregion

package/dist/build/output-root-externals.js

@@ -0,0 +1,40 @@
+import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { escapeRegExp } from "../utils/regex.js";
+import MagicString from "magic-string";
+//#region src/build/output-root-externals.ts
+/**
+* Rewrite external virtual ids into imports of files that live at a fixed
+* place relative to the output root.
+*
+* Some server modules (the cacheability manifest, the pregenerated concrete
+* paths, the Pages client assets) are written beside the server entry, and
+* deploy steps can rewrite them after the build. Rolldown leaves a relative
+* external specifier exactly as written, but it can move the importing module
+* into any chunk, for example a shared chunk under `_next/static/` when the
+* entry becomes a facade. Keeping the virtual id external and resolving it
+* against each chunk's own location keeps the import pointing at the file.
+*
+* `targets` maps each external id to its file path relative to the output root.
+*/
+function rewriteOutputRootExternals(code, chunkFileName, targets) {
+	let output = null;
+	const chunkDir = path.posix.dirname(chunkFileName);
+	for (const [id, target] of targets) {
+		if (!code.includes(id)) continue;
+		let specifier = path.posix.relative(chunkDir, target);
+		if (!specifier.startsWith(".")) specifier = `./${specifier}`;
+		const quotedId = new RegExp(`(["'])${escapeRegExp(id)}\\1`, "g");
+		for (const match of code.matchAll(quotedId)) {
+			output ??= new MagicString(code);
+			const quote = match[1];
+			output.overwrite(match.index, match.index + match[0].length, quote + specifier + quote);
+		}
+	}
+	if (output === null) return null;
+	return {
+		code: output.toString(),
+		map: output.generateMap({ hires: "boundary" })
+	};
+}
+//#endregion
+export { rewriteOutputRootExternals };

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

@@ -3,13 +3,13 @@ import { findDir } from "../utils/project.js";
 import { BLOCKED_PAGES, PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
 import { VINEXT_PRERENDER_SECRET_HEADER } from "../utils/protocol-headers.js";
 import { isExternalUrl } from "../utils/external-url.js";
+import "../server/headers.js";
 import { matchHeaders, matchesRewriteSource } from "../config/config-matchers.js";
 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 "../server/headers.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/prerender.js

@@ -3,8 +3,8 @@ import { createValidFileMatcher, findFileWithExtensions } from "../routing/file-
 import { isUnknownRecord } from "../utils/record.js";
 import { BLOCKED_PAGES } from "../shims/constants.js";
 import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_PRERENDER_SPECULATIVE_HEADER } from "../utils/protocol-headers.js";
-import { appRouteLayoutStaticParamsGroups } from "../routing/app-router.js";
 import { NEXT_CACHE_TAGS_HEADER, VINEXT_METADATA_ROUTE_CACHE_HEADER, VINEXT_PRERENDER_CACHE_LIFE_HEADER, VINEXT_PRERENDER_METADATA_ROUTES_PATH, VINEXT_PRERENDER_RENDER_ERROR_HEADER, VINEXT_PRERENDER_SPECIAL_ERROR_HEADER } from "../server/headers.js";
+import { appRouteLayoutStaticParamsGroups } from "../routing/app-router.js";
 import { extractLocaleFromUrl } from "../server/pages-i18n.js";
 import { classifyAppRoute, classifyPagesRoute, getAppRouteRenderEntryPath } from "./report.js";
 import { resolveClientStaleTimeSeconds } from "../utils/cache-control-metadata.js";

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/check.js

@@ -3,10 +3,9 @@ import path from "./deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { detectPackageManager, findDir, findViteConfigPath } from "./utils/project.js";
 import { normalizePageExtensions } from "./routing/file-matcher.js";
 import { POSTCSS_CONFIG_FILES } from "./plugins/postcss.js";
-import { unwrapExpression } from "./plugins/ast-utils.js";
+import { parseProgram, unwrapExpression } from "./plugins/ast-utils.js";
 import { require_ignore } from "./deps/.pnpm/ignore@5.3.2/deps/ignore/index.js";
 import fs from "node:fs";
-import { parseAst } from "vite";
 //#region src/check.ts
 /**
 * vinext check — compatibility scanner for Next.js apps
@@ -813,7 +812,7 @@ function propertyKeyName(prop) {
 * object — top-level keys plus, for each object-valued property, its child keys
 * (used for dot-notation options like `experimental.ppr`).
 *
-* Uses Vite's `parseAst` (the bundled oxc parser) instead of scanning text, so
+* Uses Vite's bundled oxc parser instead of scanning text, so
 * comments, string values, and other non-key mentions of an option name are
 * never mistaken for a real config option. Returns empty sets if the file cannot
 * be parsed — the check is advisory, so a parse failure simply reports nothing.
@@ -824,7 +823,7 @@ function collectConfigKeys(source) {
 	let pageExtensions;
 	let program;
 	try {
-		program = parseAst(source, { lang: "ts" });
+		program = parseProgram(source, { lang: "ts" });
 	} catch {
 		return {
 			top,
@@ -971,7 +970,7 @@ function isNextConfigWithCjsGlobals(rel, content) {
 	if (/^next\.config\.(?:ts|mts|cjs)$/.test(rel)) return true;
 	if (rel !== "next.config.js") return false;
 	try {
-		return !parseAst(content).body.some((node) => node.type === "ImportDeclaration" || node.type.startsWith("Export"));
+		return !parseProgram(content).body.some((node) => node.type === "ImportDeclaration" || node.type.startsWith("Export"));
 	} catch {
 		return false;
 	}
@@ -984,7 +983,7 @@ function isNextConfigWithCjsGlobals(rel, content) {
 function exportsPostcssPluginsOnlyObject(content) {
 	let program;
 	try {
-		program = parseAst(content, { lang: "ts" });
+		program = parseProgram(content, { lang: "ts" });
 	} catch {
 		return false;
 	}

package/dist/cli-dev-config.js

@@ -28,7 +28,7 @@ function claimViteCliDevInvocation(root, isRestart = false, isReserved = false)
 	return true;
 }
 function applyDevServerDefaults(server, options) {
-	server.port = options.port ?? server.port ?? 3e3;
+	if (options.port !== void 0) server.port = options.port;
 	server.host = options.hostname ?? server.host ?? "localhost";
 }
 function createDevServerLifecyclePlugin(options, isEnabled) {
@@ -114,7 +114,7 @@ function configureDevServerLifecycle(server) {
 	const listenServer = server.listen.bind(server);
 	server.listen = async (port, isRestart) => {
 		if (server.config.server.middlewareMode || process.env.VINEXT_NO_DEV_LOCK === "1") return listenServer(port, isRestart);
-		const configuredPort = port ?? server.config.server.port ?? 3e3;
+		const configuredPort = port ?? server.config.server.port;
 		const hostname = normalizeDevServerHostname(server.config.server.host);
 		const displayHostname = hostname === "0.0.0.0" ? "localhost" : hostname;
 		const restartingLock = activeDevServerLocks.get(root);
@@ -155,7 +155,7 @@ function configureDevServerLifecycle(server) {
 	};
 	server.httpServer?.on("listening", () => {
 		if (!activeLock) return;
-		const port = server.config.server.port ?? 3e3;
+		const port = server.config.server.port;
 		const hostname = normalizeDevServerHostname(server.config.server.host);
 		const displayHostname = hostname === "0.0.0.0" ? "localhost" : hostname;
 		const lock = activeLock;

package/dist/cli.js

@@ -364,7 +364,7 @@ function printHelp(cmd) {
     --version      Show version
 
   Examples:
-    vinext dev                         Start dev server on port 3000
+    vinext dev                         Start dev server
     vinext dev --port 4000             Start dev server on port 4000
     vinext build                       Build for production
     vinext typegen                     Generate route helper types

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`,