vinext 0.1.2 → 0.1.3

package/dist/build/prerender.d.ts

@@ -22,7 +22,8 @@ type PrerenderRouteResult = {
    * Omitted for non-dynamic routes where pattern === path.
    */
   path?: string; /** Which router produced this route. Used by cache seeding. */
-  router: "app" | "pages";
+  router: "app" | "pages"; /** Set to true when this is a PPR fallback shell. */
+  fallback?: boolean;
 } | {
   route: string;
   status: "skipped";
@@ -31,6 +32,13 @@ type PrerenderRouteResult = {
   route: string;
   status: "error";
   error: string;
+  /**
+   * Set when the error must fail the build in ALL modes (default included),
+   * not just `output: 'export'`. Used for a thrown generateStaticParams /
+   * getStaticPaths, which Next.js treats as a fatal build error rather than a
+   * silently-skipped route. Refs cloudflare/vinext#1982
+   */
+  fatal?: true;
 };
 /** Called after each route is resolved (rendered, skipped, or error). */
 type PrerenderProgressCallback = (update: {

package/dist/build/prerender.js

@@ -7,11 +7,11 @@ import { classifyAppRoute, classifyPagesRoute, getAppRouteRenderEntryPath } from
 import { BLOCKED_PAGES } from "../shims/constants.js";
 import { concatUint8Arrays, decodeRscEmbeddedChunk } from "../server/app-rsc-embedded-chunks.js";
 import { navigationRuntimeRscBootstrapExpression } from "../server/app-ssr-stream.js";
+import { createAppPprFallbackShells, markAppPprDynamicFallbackShellHtml } from "../server/app-ppr-fallback-shell.js";
 import { encodePrerenderRouteParams, serializePrerenderRouteParamsHeader } from "../server/prerender-route-params.js";
 import { readPrerenderSecret } from "./server-manifest.js";
 import { getOutputPath, getRscOutputPath } from "../utils/prerender-output-paths.js";
 import { startProdServer } from "../server/prod-server.js";
-import { createAppPprFallbackShells } from "../server/app-ppr-fallback-shell.js";
 import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
@@ -33,9 +33,21 @@ import os from "node:os";
 *   'default'  — skips SSR routes (served at request time); ISR routes rendered
 *   'export'   — SSR routes are build errors; ISR treated as static (no revalidate)
 */
+const EXPERIMENTAL_PPR_FALLBACK_SHELLS_ENV = "__VINEXT_EXPERIMENTAL_PPR_FALLBACK_SHELLS";
+function isExperimentalPprFallbackShellGenerationEnabled(env = process.env) {
+	return env[EXPERIMENTAL_PPR_FALLBACK_SHELLS_ENV] === "1";
+}
 function getErrorMessageWithStack(err) {
 	return err.stack || err.message;
 }
+var PrerenderUserFunctionError = class extends Error {};
+function parsePrerenderEndpointError(text) {
+	try {
+		const parsed = JSON.parse(text);
+		if (parsed && typeof parsed === "object" && "error" in parsed) return typeof parsed.error === "string" && parsed.error.length > 0 ? parsed.error : "Unknown prerender endpoint error";
+	} catch {}
+	return text || "Unknown prerender endpoint error";
+}
 /** Sentinel path used to trigger 404 rendering without a real route match. */
 const NOT_FOUND_SENTINEL_PATH = "/__vinext_nonexistent_for_404__";
 const DEFAULT_CONCURRENCY = Math.min(os.availableParallelism(), 8);
@@ -275,6 +287,7 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 				const res = await fetch(`${baseUrl}/__vinext/prerender/pages-static-paths?${search}`, { headers: secretHeaders });
 				const text = await res.text();
 				if (!res.ok) {
+					if (res.status === 500) throw new PrerenderUserFunctionError(parsePrerenderEndpointError(text));
 					console.warn(`[vinext] Warning: /__vinext/prerender/pages-static-paths returned ${res.status} for ${r.pattern}. Dynamic paths will be skipped. This may indicate a stale or missing prerender secret.`);
 					return {
 						paths: [],
@@ -322,10 +335,21 @@ async function prerenderPages({ routes, apiRoutes, pagesDir, outDir, config, mod
 					});
 					continue;
 				}
-				const pathsResult = await route.module.getStaticPaths({
-					locales: [],
-					defaultLocale: ""
-				});
+				let pathsResult;
+				try {
+					pathsResult = await route.module.getStaticPaths({
+						locales: [],
+						defaultLocale: ""
+					});
+				} catch (e) {
+					results.push({
+						route: route.pattern,
+						status: "error",
+						error: `Failed to call getStaticPaths(): ${e.message}`,
+						...e instanceof PrerenderUserFunctionError ? { fatal: true } : {}
+					});
+					continue;
+				}
 				const fallback = pathsResult?.fallback ?? false;
 				if (mode === "export" && fallback !== false) {
 					results.push({
@@ -521,6 +545,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 						const res = await fetch(`${baseUrl}/__vinext/prerender/static-params?${search}`, { headers: secretHeaders });
 						const text = await res.text();
 						if (!res.ok) {
+							if (res.status === 500) throw new PrerenderUserFunctionError(parsePrerenderEndpointError(text));
 							console.warn(`[vinext] Warning: /__vinext/prerender/static-params returned ${res.status} for ${pattern}. Static params will be skipped. This may indicate a stale or missing prerender secret.`);
 							return null;
 						}
@@ -642,7 +667,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 						revalidate,
 						isSpeculative: false
 					});
-					if (config.cacheComponents === true) for (const fallbackShell of createAppPprFallbackShells(route, params)) {
+					if (config.cacheComponents === true && isExperimentalPprFallbackShellGenerationEnabled()) for (const fallbackShell of createAppPprFallbackShells(route, params)) {
 						if (queuedRouteUrls.has(fallbackShell.pathname)) continue;
 						queuedRouteUrls.add(fallbackShell.pathname);
 						urlsToRender.push({
@@ -650,7 +675,8 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 							routePattern: route.pattern,
 							prerenderRouteParams: encodePrerenderRouteParams(route.pattern, fallbackShell.params, fallbackShell.fallbackParamNames),
 							revalidate,
-							isSpeculative: false
+							isSpeculative: false,
+							isFallback: true
 						});
 					}
 				}
@@ -660,7 +686,8 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 				results.push({
 					route: route.pattern,
 					status: "error",
-					error: `Failed to call generateStaticParams(): ${detail}`
+					error: `Failed to call generateStaticParams(): ${detail}`,
+					...e instanceof PrerenderUserFunctionError ? { fatal: true } : {}
 				});
 			}
 			else if (type === "unknown") urlsToRender.push({
@@ -684,7 +711,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 		* exactly once per URL after this function returns, keeping the callback
 		* at a single, predictable call site.
 		*/
-		async function renderUrl({ urlPath, routePattern, prerenderRouteParams, revalidate, isSpeculative }) {
+		async function renderUrl({ urlPath, routePattern, prerenderRouteParams, revalidate, isSpeculative, isFallback }) {
 			try {
 				const prerenderRouteParamsHeader = serializePrerenderRouteParamsHeader(prerenderRouteParams);
 				const htmlHeaders = new Headers();
@@ -736,7 +763,7 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					status: "error",
 					error: "RSC handler returned no prerender HTML"
 				};
-				const html = htmlRender.html;
+				const html = isFallback ? markAppPprDynamicFallbackShellHtml(htmlRender.html) : htmlRender.html;
 				let rscData = extractRscPayloadFromPrerenderedHtml(html);
 				if (rscData === null) {
 					const rscHeaders = new Headers({
@@ -772,7 +799,8 @@ async function prerenderApp({ routes, metadataRoutes = [], outDir, config, mode,
 					revalidate: renderedRevalidate,
 					...typeof renderedRevalidate === "number" ? { expire: renderedCacheControl.expire } : {},
 					router: "app",
-					...urlPath !== routePattern ? { path: urlPath } : {}
+					...urlPath !== routePattern ? { path: urlPath } : {},
+					...isFallback ? { fallback: true } : {}
 				};
 			} catch (e) {
 				if (isSpeculative) return {
@@ -878,7 +906,8 @@ function writePrerenderIndex(routes, outDir, options) {
 			revalidate: r.revalidate,
 			...typeof r.revalidate === "number" ? { expire: r.expire } : {},
 			router: r.router,
-			...r.path ? { path: r.path } : {}
+			...r.path ? { path: r.path } : {},
+			...r.fallback ? { fallback: true } : {}
 		};
 		if (r.status === "skipped") return {
 			route: r.route,

package/dist/build/run-prerender.d.ts

@@ -1,5 +1,5 @@
 import { ResolvedNextConfig } from "../config/next-config.js";
-import { PrerenderResult } from "./prerender.js";
+import { PrerenderResult, PrerenderRouteResult } from "./prerender.js";
 
 //#region src/build/run-prerender.d.ts
 type RunPrerenderOptions = {
@@ -48,6 +48,14 @@ type RunPrerenderOptions = {
  * If a required production bundle does not exist, an error is thrown directing
  * the user to run `vinext build` first.
  */
+/**
+ * Throw if any route is a `fatal` error (a thrown generateStaticParams /
+ * getStaticPaths). These fail the build in ALL modes — default included —
+ * matching `next build`, unlike intentionally-skipped dynamic/SSR routes and
+ * non-fatal errors (e.g. transport failures), which only fail under
+ * `output: 'export'`. Exported for direct unit testing. Refs cloudflare/vinext#1982
+ */
+declare function assertNoFatalPrerenderRoutes(routes: readonly PrerenderRouteResult[]): void;
 declare function runPrerender(options: RunPrerenderOptions): Promise<PrerenderResult | null>;
 //#endregion
-export { runPrerender };
+export { assertNoFatalPrerenderRoutes, runPrerender };

package/dist/build/run-prerender.js

@@ -82,6 +82,19 @@ function readBuiltBuildId(serverDir) {
 * If a required production bundle does not exist, an error is thrown directing
 * the user to run `vinext build` first.
 */
+/**
+* Throw if any route is a `fatal` error (a thrown generateStaticParams /
+* getStaticPaths). These fail the build in ALL modes — default included —
+* matching `next build`, unlike intentionally-skipped dynamic/SSR routes and
+* non-fatal errors (e.g. transport failures), which only fail under
+* `output: 'export'`. Exported for direct unit testing. Refs cloudflare/vinext#1982
+*/
+function assertNoFatalPrerenderRoutes(routes) {
+	const fatalRoutes = routes.filter((r) => r.status === "error" && r.fatal === true);
+	if (fatalRoutes.length === 0) return;
+	const fatalList = fatalRoutes.map((r) => `  ${r.route}: ${r.error}`).join("\n");
+	throw new Error(`Prerender failed: ${fatalRoutes.length} route${fatalRoutes.length !== 1 ? "s" : ""} errored during static generation.\n${fatalList}`);
+}
 async function runPrerender(options) {
 	const { root } = options;
 	const appDir = findDir(root, "app", "src/app");
@@ -197,6 +210,7 @@ async function runPrerender(options) {
 	} finally {
 		progress.finish(rendered, skipped, errors);
 	}
+	assertNoFatalPrerenderRoutes(allRoutes);
 	if (mode === "export" && errors > 0) {
 		const errorRoutes = allRoutes.filter((r) => r.status === "error").map((r) => `  ${r.route}: ${r.error}`).join("\n");
 		throw new Error(`Static export failed: ${errors} route${errors !== 1 ? "s" : ""} cannot be statically exported.\n${errorRoutes}\n\nRemove server-side data fetching (getServerSideProps, force-dynamic, revalidate) from these routes, or remove \`output: "export"\` from next.config.js.`);
@@ -207,4 +221,4 @@ async function runPrerender(options) {
 	};
 }
 //#endregion
-export { runPrerender };
+export { assertNoFatalPrerenderRoutes, runPrerender };

package/dist/client/app-nav-failure-handler.d.ts

@@ -0,0 +1,8 @@
+//#region src/client/app-nav-failure-handler.d.ts
+declare function stageAppNavigationFailureTarget(href: string): void;
+declare function getAppNavigationFailureTarget(href: string): URL | null;
+declare function clearAppNavigationFailureTarget(target?: string | URL): void;
+declare function handleAppNavigationFailure(error: unknown): boolean;
+declare function installAppNavigationFailureListeners(): () => void;
+//#endregion
+export { clearAppNavigationFailureTarget, getAppNavigationFailureTarget, handleAppNavigationFailure, installAppNavigationFailureListeners, stageAppNavigationFailureTarget };

package/dist/client/app-nav-failure-handler.js

@@ -0,0 +1,44 @@
+import { installWindowNext } from "./window-next.js";
+//#region src/client/app-nav-failure-handler.ts
+function getPendingUrl() {
+	if (typeof window === "undefined") return null;
+	return window.next?.__pendingUrl ?? null;
+}
+function stageAppNavigationFailureTarget(href) {
+	if (!process.env.__NEXT_APP_NAV_FAIL_HANDLING || typeof window === "undefined") return;
+	installWindowNext({ __pendingUrl: new URL(href, window.location.href) });
+}
+function getAppNavigationFailureTarget(href) {
+	const pendingUrl = getPendingUrl();
+	if (pendingUrl === null || typeof window === "undefined") return null;
+	return pendingUrl.href === new URL(href, window.location.href).href ? pendingUrl : null;
+}
+function clearAppNavigationFailureTarget(target) {
+	if (typeof window === "undefined" || window.next?.__pendingUrl === void 0) return;
+	if (target instanceof URL) {
+		if (window.next.__pendingUrl !== target) return;
+	} else if (target !== void 0 && window.next.__pendingUrl.href !== new URL(target, window.location.href).href) return;
+	delete window.next.__pendingUrl;
+}
+function handleAppNavigationFailure(error) {
+	if (!process.env.__NEXT_APP_NAV_FAIL_HANDLING || typeof window === "undefined") return false;
+	const pendingUrl = getPendingUrl();
+	if (pendingUrl === null || pendingUrl.href === window.location.href) return false;
+	console.error("Error occurred during navigation, falling back to hard navigation", error);
+	window.location.assign(pendingUrl.href);
+	return true;
+}
+function installAppNavigationFailureListeners() {
+	if (!process.env.__NEXT_APP_NAV_FAIL_HANDLING || typeof window === "undefined") return () => {};
+	const listener = (event) => {
+		handleAppNavigationFailure("reason" in event ? event.reason : event.error);
+	};
+	window.addEventListener("error", listener);
+	window.addEventListener("unhandledrejection", listener);
+	return () => {
+		window.removeEventListener("error", listener);
+		window.removeEventListener("unhandledrejection", listener);
+	};
+}
+//#endregion
+export { clearAppNavigationFailureTarget, getAppNavigationFailureTarget, handleAppNavigationFailure, installAppNavigationFailureListeners, stageAppNavigationFailureTarget };

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

@@ -3,6 +3,23 @@ import { NEXT_DATA } from "../shims/internal/utils.js";
 //#region src/client/vinext-next-data.d.ts
 type VinextLinkPrefetchRoute = {
   canPrefetchLoadingShell: boolean;
+  documentOnly?: boolean;
+  isDynamic: boolean;
+  patternParts: string[];
+};
+/**
+ * Pages Router route pattern exposed to the client so the App Router's
+ * navigation runtime can decide whether a soft-navigated URL should be
+ * handled by Pages (hard nav) or App (RSC). Mirrors the public shape of
+ * `VinextLinkPrefetchRoute` so a single trie matcher handles both.
+ *
+ * `canPrefetchLoadingShell` is always `false` for Pages routes — Pages
+ * does not have a separate loading boundary and its prefetch surface is
+ * `_next/data/<buildId>/<page>.json`.
+ */
+type VinextPagesLinkPrefetchRoute = {
+  canPrefetchLoadingShell: false;
+  documentOnly?: boolean;
   isDynamic: boolean;
   patternParts: string[];
 };
@@ -24,4 +41,4 @@ declare function extractVinextNextDataJson(html: string): string | null;
 declare function parseVinextNextDataJson(json: string): BrowserVinextNextData;
 declare function applyVinextLocaleGlobals(target: VinextLocaleGlobalTarget, nextData: VinextNextData): void;
 //#endregion
-export { VinextLinkPrefetchRoute, VinextNextData, applyVinextLocaleGlobals, extractVinextNextDataJson, parseVinextNextDataJson };
+export { VinextLinkPrefetchRoute, VinextNextData, VinextPagesLinkPrefetchRoute, applyVinextLocaleGlobals, extractVinextNextDataJson, parseVinextNextDataJson };

package/dist/client/window-next.d.ts

@@ -163,5 +163,6 @@ type WindowNext = {
  * resets state.
  */
 declare function installWindowNext(fields: Partial<WindowNext>): void;
+declare function setWindowNextInternalSourcePage(sourcePage: string | null): void;
 //#endregion
-export { PagesRouterPublicInstance, installWindowNext };
+export { PagesRouterPublicInstance, installWindowNext, setWindowNextInternalSourcePage };

package/dist/client/window-next.js

@@ -42,5 +42,16 @@ function installWindowNext(fields) {
 		...fields
 	};
 }
+function setWindowNextInternalSourcePage(sourcePage) {
+	if (typeof window === "undefined") return;
+	installWindowNext({});
+	if (sourcePage === null) {
+		delete window.next?.__internal_src_page;
+		return;
+	}
+	const next = window.next;
+	if (!next) return;
+	next.__internal_src_page = sourcePage;
+}
 //#endregion
-export { installWindowNext };
+export { installWindowNext, setWindowNextInternalSourcePage };

package/dist/cloudflare/src/cache/cdn-adapter.runtime.js

@@ -73,7 +73,12 @@ var CloudflareCdnCacheAdapter = class {
 	async set(_key, _data, _ctx) {}
 	buildResponseHeaders(input) {
 		if (!input.cacheControl) return { "Cache-Control": NO_STORE };
-		if (/\b(?:no-store|no-cache|private)\b/.test(input.cacheControl)) return { "Cache-Control": input.cacheControl };
+		if (/\b(?:no-store|no-cache|private)\b/.test(input.cacheControl)) return {
+			"Cache-Control": input.cacheControl,
+			"CDN-Cache-Control": null,
+			"Cloudflare-CDN-Cache-Control": null,
+			"Cache-Tag": null
+		};
 		const headers = {
 			"Cache-Control": BROWSER_REVALIDATE,
 			"CDN-Cache-Control": toEdgeCacheControl(input.cacheControl)

package/dist/config/config-matchers.js

@@ -1,5 +1,6 @@
 import { VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER } from "../server/headers.js";
 import { buildRequestHeadersFromMiddlewareResponse } from "../server/middleware-request-headers.js";
+import { parseCookieHeader } from "../utils/parse-cookie.js";
 //#region src/config/config-matchers.ts
 /**
 * Cache for compiled regex patterns in matchConfigPattern.
@@ -343,16 +344,7 @@ function shouldEvaluateRule(ruleBasePath, state) {
 * Parse a Cookie header string into a key-value record.
 */
 function parseCookies(cookieHeader) {
-	if (!cookieHeader) return {};
-	const cookies = {};
-	for (const part of cookieHeader.split(";")) {
-		const eq = part.indexOf("=");
-		if (eq === -1) continue;
-		const key = part.slice(0, eq).trim();
-		const value = part.slice(eq + 1).trim();
-		if (key) cookies[key] = value;
-	}
-	return cookies;
+	return parseCookieHeader(cookieHeader);
 }
 /**
 * Build a RequestContext from a Web Request object.
@@ -442,8 +434,8 @@ function matchSingleCondition(condition, ctx) {
 			return _matchConditionValue(headerValue, condition.value);
 		}
 		case "cookie": {
+			if (!Object.hasOwn(ctx.cookies, condition.key)) return null;
 			const cookieValue = ctx.cookies[condition.key];
-			if (cookieValue === void 0) return null;
 			return _matchConditionValue(cookieValue, condition.value);
 		}
 		case "query": {
@@ -541,7 +533,7 @@ function matchConfigPattern(pathname, pattern) {
 	pathname = stripTrailingSlashForConfigMatch(pathname);
 	const catchAllAnchor = /:[\w-]+[*+]/.test(pattern);
 	const namedParamCount = (pattern.match(/:[\w-]+/g) || []).length;
-	if (pattern.includes("(") || pattern.includes("\\") || /:[\w-]+[*+][^/]/.test(pattern) || /:[\w-]+\./.test(pattern) || catchAllAnchor && namedParamCount > 1) try {
+	if (pattern.includes("(") || pattern.includes("\\") || /:[\w-]+[*+][^/]/.test(pattern) || /:[\w-]+\./.test(pattern) || /[^/]:[\w-]+/.test(pattern) || catchAllAnchor && namedParamCount > 1) try {
 		const compiled = getCachedRegex(_compiledPatternCache, pattern, () => {
 			const paramNames = [];
 			let regexStr = "";
@@ -716,10 +708,11 @@ function matchRewrite(pathname, rewrites, ctx, basePathState = _BASEPATH_DEFAULT
 		if (params) {
 			const conditionParams = rewrite.has || rewrite.missing ? collectConditionParams(rewrite.has, rewrite.missing, ctx) : _emptyParams();
 			if (!conditionParams) continue;
-			return substituteAndSanitizeDestination(rewrite.destination, {
+			const rewriteParams = {
 				...params,
 				...conditionParams
-			});
+			};
+			return substituteAndSanitizeRewriteDestination(rewrite.destination, rewriteParams);
 		}
 	}
 	return null;
@@ -753,6 +746,72 @@ function substituteAndSanitizeDestination(destination, params) {
 	return sanitizeDestination(substituteDestinationParams(destination, params));
 }
 /**
+* Match Next.js's rewrite-specific prepareDestination behavior: source params
+* that are not consumed by the destination path/host are exposed to the target
+* page through query.
+*
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/router/utils/prepare-destination.ts
+*/
+function substituteAndSanitizeRewriteDestination(destination, params) {
+	const rewritten = substituteAndSanitizeDestination(destination, params);
+	if (!shouldAppendRewriteParamsToQuery(destination, params)) return rewritten;
+	const existingQueryKeys = getDestinationQueryKeys(destination);
+	const paramsToAppend = [];
+	for (const [key, value] of Object.entries(params)) {
+		if (key === "nextInternalLocale" || existingQueryKeys.has(key)) continue;
+		paramsToAppend.push([key, value]);
+	}
+	if (paramsToAppend.length === 0) return rewritten;
+	return appendQueryParams(rewritten, paramsToAppend);
+}
+function shouldAppendRewriteParamsToQuery(destination, params) {
+	const keys = Object.keys(params).filter((key) => key !== "nextInternalLocale");
+	if (keys.length === 0) return false;
+	return !destinationPathOrHostUsesParam(destination, keys);
+}
+function destinationPathOrHostUsesParam(destination, keys) {
+	const pathAndHost = getDestinationPathAndHost(destination);
+	if (!pathAndHost) return false;
+	for (const key of keys) {
+		const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		if (new RegExp(`:${escapedKey}([+*])?(?![A-Za-z0-9_])`).test(pathAndHost)) return true;
+	}
+	return false;
+}
+function getDestinationPathAndHost(destination) {
+	const hashIndex = destination.indexOf("#");
+	const beforeHash = hashIndex === -1 ? destination : destination.slice(0, hashIndex);
+	const hash = hashIndex === -1 ? "" : destination.slice(hashIndex);
+	const queryIndex = beforeHash.indexOf("?");
+	const beforeQuery = queryIndex === -1 ? beforeHash : beforeHash.slice(0, queryIndex);
+	const schemeMatch = /^[a-z][a-z0-9+.-]*:\/\//i.exec(beforeQuery);
+	if (!schemeMatch) return `${beforeQuery}${hash}`;
+	const withoutScheme = beforeQuery.slice(schemeMatch[0].length);
+	const slashIndex = withoutScheme.indexOf("/");
+	if (slashIndex === -1) return `${withoutScheme}${hash}`;
+	return `${withoutScheme.slice(0, slashIndex)}${withoutScheme.slice(slashIndex)}${hash}`;
+}
+function getDestinationQueryKeys(destination) {
+	const hashIndex = destination.indexOf("#");
+	const beforeHash = hashIndex === -1 ? destination : destination.slice(0, hashIndex);
+	const queryIndex = beforeHash.indexOf("?");
+	if (queryIndex === -1) return /* @__PURE__ */ new Set();
+	const query = beforeHash.slice(queryIndex + 1);
+	return new Set(new URLSearchParams(query).keys());
+}
+function appendQueryParams(url, params) {
+	const hashIndex = url.indexOf("#");
+	const beforeHash = hashIndex === -1 ? url : url.slice(0, hashIndex);
+	const hash = hashIndex === -1 ? "" : url.slice(hashIndex);
+	const queryIndex = beforeHash.indexOf("?");
+	const base = queryIndex === -1 ? beforeHash : beforeHash.slice(0, queryIndex);
+	const query = queryIndex === -1 ? "" : beforeHash.slice(queryIndex + 1);
+	const merged = new URLSearchParams(query);
+	for (const [key, value] of params) merged.append(key, value);
+	const search = merged.toString();
+	return `${base}${search ? `?${search}` : ""}${hash}`;
+}
+/**
 * Sanitize a redirect/rewrite destination to collapse protocol-relative URLs.
 *
 * After parameter substitution, a destination like `/:path*` can become

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

@@ -117,14 +117,20 @@ type NextConfig = {
     domains?: string[];
     unoptimized?: boolean; /** Allowed device widths for image optimization. Defaults to Next.js defaults: [640, 750, 828, 1080, 1200, 1920, 2048, 3840] */
     deviceSizes?: number[]; /** Allowed image sizes for fixed-width images. Defaults to Next.js defaults: [16, 32, 48, 64, 96, 128, 256, 384] */
-    imageSizes?: number[]; /** Allow SVG images through the image optimization endpoint. SVG can contain scripts, so only enable if you trust all image sources. */
+    imageSizes?: number[]; /** Allowed image qualities. When unset, any quality from 1-100 is permitted (matches Next.js). */
+    qualities?: number[]; /** Allow SVG images through the image optimization endpoint. SVG can contain scripts, so only enable if you trust all image sources. */
     dangerouslyAllowSVG?: boolean; /** Allow image optimization for hostnames that resolve to private IP addresses. This is a security risk (SSRF) — only enable for private networks when you understand the risk. */
     dangerouslyAllowLocalIP?: boolean; /** Content-Disposition header for image responses. Defaults to "inline". */
     contentDispositionType?: "inline" | "attachment"; /** Content-Security-Policy header for image responses. Defaults to "script-src 'none'; frame-src 'none'; sandbox;" */
     contentSecurityPolicy?: string;
   }; /** Build output mode: 'export' for full static export, 'standalone' for single server */
   output?: "export" | "standalone"; /** File extensions treated as routable pages/routes (Next.js pageExtensions) */
-  pageExtensions?: string[];
+  pageExtensions?: string[]; /** Turbopack-compatible module resolution options. */
+  turbopack?: {
+    resolveAlias?: Record<string, unknown>;
+    resolveExtensions?: string[];
+    [key: string]: unknown;
+  };
   /**
    * Module specifiers that are required for side effects on the client before
    * hydration, in array order, ahead of the user's `instrumentation-client.{ts,js}`.
@@ -182,6 +188,7 @@ type NextConfig = {
     defineServer?: Record<string, string | number | boolean>;
   };
   experimental?: {
+    /** Enables hard-navigation recovery when App Router navigation rendering fails. */appNavFailHandling?: boolean;
     /**
      * Enables the experimental App Router gesture transition API:
      * `useRouter().experimental_gesturePush()`.
@@ -236,8 +243,11 @@ type ResolvedNextConfig = {
   trailingSlash: boolean;
   output: "" | "export" | "standalone";
   pageExtensions: string[];
+  resolveExtensions: string[] | null;
+  serverResolveExtensions: string[] | null;
   instrumentationClientInject: string[];
   cacheComponents: boolean;
+  appNavFailHandling: boolean;
   /**
    * Enables the experimental App Router gesture transition API:
    * `useRouter().experimental_gesturePush()`.
@@ -337,6 +347,13 @@ type ResolvedNextConfig = {
    * `test/e2e/optimized-loading` test fixture.
    */
   disableOptimizedLoading: boolean;
+  /**
+   * Mirrors Next.js `experimental.scrollRestoration`. When true, the Pages
+   * Router client takes ownership of browser history scroll restoration by
+   * setting `window.history.scrollRestoration = "manual"` and snapshotting
+   * scroll positions per history entry.
+   */
+  scrollRestoration: boolean;
   /**
    * Build-time constant replacement map applied to BOTH client and server
    * bundles. Sourced from `compiler.define` in next.config. Values are
@@ -378,6 +395,28 @@ type ResolvedNextConfig = {
     dynamic: number;
     static: number;
   };
+  /**
+   * Mirrors Next.js `experimental.useLightningcss`. When `true`, switch
+   * Vite's CSS pipeline from PostCSS to lightningcss for both transforms
+   * and minification, so the user's `lightningCssFeatures` config takes
+   * effect (without this flag set, Next.js's own
+   * `lightningCssFeatures` option is also a no-op).
+   *
+   * @see https://nextjs.org/docs/app/api-reference/config/next-config-js/useLightningcss
+   */
+  useLightningcss: boolean;
+  /**
+   * Resolved `experimental.lightningCssFeatures` from next.config, converted
+   * from dash-case feature names into the numeric bitmask form expected by
+   * the lightningcss `transform()` API (`include` / `exclude` options). When
+   * the user did not supply the option, both masks are `0` (a no-op).
+   *
+   * @see https://nextjs.org/docs/app/api-reference/config/next-config-js/lightningCssFeatures
+   */
+  lightningCssFeatures: {
+    include: number;
+    exclude: number;
+  };
 };
 /**
  * Whole-word substring check for any of the CJS-style globals that the
@@ -457,11 +496,14 @@ declare function normalizeAssetPrefix(value: unknown): string;
  * resolve it once and share it — see `__VINEXT_SHARED_RSC_COMPATIBILITY_ID`.
  */
 declare function createRscCompatibilityId(nextConfig: Pick<ResolvedNextConfig, "deploymentId">): string;
+declare function lightningCssFeatureNamesToMask(names: readonly string[]): number;
 /**
  * Resolve a NextConfig into a fully-resolved ResolvedNextConfig.
  * Awaits async functions for redirects/rewrites/headers.
  */
-declare function resolveNextConfig(config: NextConfig | null, root?: string): Promise<ResolvedNextConfig>;
+declare function resolveNextConfig(config: NextConfig | null, root?: string, options?: {
+  dev?: boolean;
+}): Promise<ResolvedNextConfig>;
 /**
  * Extract MDX compilation options (remark/rehype/recma plugins) from
  * a Next.js config that uses @next/mdx.
@@ -489,4 +531,4 @@ declare function extractMdxOptions(config: NextConfig, root?: string): Promise<M
  */
 declare function detectNextIntlConfig(root: string, resolved: ResolvedNextConfig): void;
 //#endregion
-export { HasCondition, MdxOptions, NextConfig, NextConfigInput, NextHeader, NextI18nConfig, NextRedirect, NextRewrite, PHASE_PRODUCTION_BUILD, ResolvedNextConfig, createRscCompatibilityId, detectNextIntlConfig, extractMdxOptions, findNextConfigPath, loadNextConfig, normalizeAssetPrefix, parseBodySizeLimit, reassignsModuleExports, referencesCjsGlobals, resolveNextConfig, resolveNextConfigInput };
+export { HasCondition, MdxOptions, NextConfig, NextConfigInput, NextHeader, NextI18nConfig, NextRedirect, NextRewrite, PHASE_PRODUCTION_BUILD, ResolvedNextConfig, createRscCompatibilityId, detectNextIntlConfig, extractMdxOptions, findNextConfigPath, lightningCssFeatureNamesToMask, loadNextConfig, normalizeAssetPrefix, parseBodySizeLimit, reassignsModuleExports, referencesCjsGlobals, resolveNextConfig, resolveNextConfigInput };