vinext 1.3.0 → 1.4.0

package/dist/client/client-redirects.d.ts

@@ -1,7 +1,7 @@
 import { NextRedirect, ResolvedNextConfig } from "../config/next-config.js";
 import { ClientHasCondition } from "./client-rewrites.js";
 //#region src/client/client-redirects.d.ts
-type ClientRedirectFields = Pick<NextRedirect, "basePath" | "locale" | "source"> & {
+type ClientRedirectFields = Pick<NextRedirect, "basePath" | "defaultLocaleVariant" | "locale" | "source"> & {
   has?: ClientHasCondition[];
   missing?: ClientHasCondition[];
 };
@@ -16,7 +16,7 @@ type ClientRedirectFields = Pick<NextRedirect, "basePath" | "locale" | "source">
  */
 export type ClientRedirect = (ClientRedirectFields & {
   destination: string;
-  permanent: boolean;
+  permanent?: boolean;
   requiresServerEvaluation?: never;
 }) | (ClientRedirectFields & {
   destination?: never;
@@ -24,4 +24,5 @@ export type ClientRedirect = (ClientRedirectFields & {
   requiresServerEvaluation: true;
 });
 export declare function toClientRedirects(redirects: ResolvedNextConfig["redirects"]): ClientRedirect[];
-//#endregion
+//#endregion
+export {};

package/dist/client/client-redirects.js

@@ -9,7 +9,8 @@ function toClientRedirect(redirect) {
 		has: clientHas?.length ? clientHas : void 0,
 		missing: clientMissing?.length ? clientMissing : void 0,
 		locale: redirect.locale,
-		basePath: redirect.basePath
+		basePath: redirect.basePath,
+		defaultLocaleVariant: redirect.defaultLocaleVariant
 	};
 	if (hasServerOnlyCondition) return {
 		...common,

package/dist/client/client-rewrites.d.ts

@@ -28,4 +28,5 @@ export type ClientRewrites = {
 };
 export declare function isClientHasCondition(condition: HasCondition): condition is ClientHasCondition;
 export declare function toClientRewrites(rewrites: ResolvedNextConfig["rewrites"]): ClientRewrites;
-//#endregion
+//#endregion
+export {};

package/dist/client/dev-error-overlay-store.d.ts

@@ -35,4 +35,5 @@ export declare function dismissOverlay(): void;
 export declare function setOverlayIndex(index: number): void;
 export declare function minimizeOverlay(): void;
 export declare function expandOverlay(): void;
-//#endregion
+//#endregion
+export {};

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

@@ -1,7 +1,7 @@
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
-import { VINEXT_DEV_ERROR_RECOVERY_EVENT } from "../utils/dev-error-recovery-event.js";
 import { VINEXT_ORIGINAL_STACK_TRACE_ENDPOINT } from "../utils/dev-stack-sourcemap-endpoint.js";
 import { dismissOverlay, expandOverlay, getOverlaySnapshot, minimizeOverlay, reportToOverlay, setOverlayIndex, subscribeOverlay, updateOverlayErrorStack } from "./dev-error-overlay-store.js";
+import { VINEXT_DEV_ERROR_RECOVERY_EVENT } from "../utils/dev-error-recovery-event.js";
 import { Fragment, useEffect, useMemo, useState, useSyncExternalStore } from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 import { createRoot } from "react-dom/client";

package/dist/client/index.js

@@ -1,2 +1 @@
-import { getVinextReact } from "./react-instance.js";
-export { getVinextReact };
+export { getVinextReact } from "./react-instance.js";

package/dist/client/instrumentation-client-state.js

@@ -1,17 +1,17 @@
 //#region src/client/instrumentation-client-state.ts
-let clientInstrumentationHooks = null;
+const VINEXT_CLIENT_INSTRUMENTATION_HOOKS = Symbol.for("vinext.client.instrumentationHooks");
 function normalizeClientInstrumentationHooks(hooks) {
 	return Object.values(hooks).some((value) => typeof value === "function") ? hooks : null;
 }
 function setClientInstrumentationHooks(hooks) {
-	clientInstrumentationHooks = hooks;
-	return clientInstrumentationHooks;
+	Reflect.set(globalThis, VINEXT_CLIENT_INSTRUMENTATION_HOOKS, hooks);
+	return hooks;
 }
 function getClientInstrumentationHooks() {
-	return clientInstrumentationHooks;
+	return Reflect.get(globalThis, VINEXT_CLIENT_INSTRUMENTATION_HOOKS) ?? null;
 }
 function notifyAppRouterTransitionStart(href, navigationType) {
-	clientInstrumentationHooks?.onRouterTransitionStart?.(href, navigationType);
+	getClientInstrumentationHooks()?.onRouterTransitionStart?.(href, navigationType);
 }
 //#endregion
 export { getClientInstrumentationHooks, normalizeClientInstrumentationHooks, notifyAppRouterTransitionStart, setClientInstrumentationHooks };

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

@@ -1,5 +1,6 @@
 import { BrowserRouteManifest, BrowserRouteManifestWire } from "../routing/browser-route-manifest.js";
 import { AppRouterScrollIntent } from "../shims/app-router-scroll-state.js";
+import { CachedRscResponse } from "../shims/navigation.js";
 //#region src/client/navigation-runtime.d.ts
 type NavigationRuntimeSnapshot = {
   pathname: string;
@@ -42,7 +43,9 @@ type NavigationRuntimeTraversalIntent = {
 };
 export type NavigationRuntimeNavigate = (href: string, redirectDepth?: number, navigationKind?: NavigationRuntimeKind, historyUpdateMode?: NavigationRuntimeHistoryUpdateMode, previousNextUrlOverride?: string | null, programmaticTransition?: boolean, traversalIntent?: NavigationRuntimeTraversalIntent, scrollIntent?: AppRouterScrollIntent | null, visibleCommitMode?: NavigationRuntimeVisibleCommitMode, bypassNavigationCache?: boolean) => Promise<void>;
 export type NavigationRuntimeFunctions = {
-  clearNavigationCaches?: () => void;
+  clearNavigationCaches?: (options?: {
+    pingVisibleLinks?: boolean;
+  }) => void;
   commitHashNavigation?: (href: string, historyUpdateMode: NavigationRuntimeHistoryUpdateMode, scroll: boolean) => void;
   navigateExternal?: (href: string, historyUpdateMode: NavigationRuntimeHistoryUpdateMode) => Promise<void>;
   navigate?: NavigationRuntimeNavigate;
@@ -57,6 +60,15 @@ export type NavigationRuntimeFunctions = {
   notifyLinkNavigationStart?: () => void;
   pingVisibleLinks?: () => void;
   preparePrefetchResponse?: (response: Response) => Promise<unknown>;
+  /**
+   * The visited (BFCache) response a full prefetch can be fulfilled from, and
+   * until when a navigation would still reuse it (null if it wouldn't).
+   */
+  readVisitedResponseForFullPrefetch?: (rscUrls: readonly string[], interceptionContext: string | null, mountedSlotsHeader: string | null) => {
+    navigatedAt: number;
+    navigationFreshUntil: number | null;
+    response: CachedRscResponse;
+  } | null;
   claimCurrentHistoryTreeSnapshot?: (historyUpdateMode: NavigationRuntimeHistoryUpdateMode, previousHistoryState: unknown) => void;
   commitAppOwnedHistoryStateWrite?: (historyUpdateMode: NavigationRuntimeHistoryUpdateMode, previousHistoryState: unknown) => void;
   /**
@@ -86,6 +98,7 @@ export type NavigationRuntime = {
   functions: NavigationRuntimeFunctions;
 };
 export declare const NAVIGATION_RUNTIME_KEY: unique symbol;
+export declare function isNavigationRuntimeFunctions(value: unknown): value is NavigationRuntimeFunctions;
 export declare function getNavigationRuntime(): NavigationRuntime | null;
 export declare function registerNavigationRuntimeBootstrap(bootstrap: Partial<NavigationRuntimeBootstrap>): NavigationRuntime;
 export declare function registerNavigationRuntimeFunctions(functions: Partial<NavigationRuntimeFunctions>): NavigationRuntime;
@@ -119,4 +132,5 @@ export declare function hasAppNavigationRuntime(): boolean;
  * tag) should call this instead.
  */
 export declare function hasAppNavigationRuntimeBootstrap(): boolean;
-//#endregion
+//#endregion
+export {};

package/dist/client/navigation-runtime.js

@@ -26,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")) && isOptionalRuntimeFunction(Reflect.get(value, "loadRouteManifest"));
+	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, "readVisitedResponseForFullPrefetch")) && 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;
@@ -200,4 +200,4 @@ function hasAppNavigationRuntimeBootstrap() {
 	return getNavigationRuntime() !== null;
 }
 //#endregion
-export { NAVIGATION_RUNTIME_KEY, createNavigationRuntimeRouteManifestLoader, ensureNavigationRuntimeRscBootstrap, getNavigationRuntime, hasAppNavigationRuntime, hasAppNavigationRuntimeBootstrap, loadNavigationRuntimeRouteManifest, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions };
+export { NAVIGATION_RUNTIME_KEY, createNavigationRuntimeRouteManifestLoader, ensureNavigationRuntimeRscBootstrap, getNavigationRuntime, hasAppNavigationRuntime, hasAppNavigationRuntimeBootstrap, isNavigationRuntimeFunctions, loadNavigationRuntimeRouteManifest, registerNavigationRuntimeBootstrap, registerNavigationRuntimeFunctions };

package/dist/client/pages-router-link-navigation.d.ts

@@ -39,4 +39,5 @@ export declare function navigatePagesRouterLinkWithFallback({ router, loadRouter
   navigation: PagesRouterLinkNavigation;
   fallback: () => void;
 }): Promise<void>;
-//#endregion
+//#endregion
+export {};

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

@@ -5,10 +5,33 @@ export type VinextLinkPrefetchRoute = {
   documentOnly?: boolean;
   isDynamic: boolean;
   patternParts: string[];
+  /**
+   * The route's segment config rules out static generation, so Next.js
+   * renders it on every request, and its automatic prefetch never renders the
+   * page. Read at build time. Never set with Cache Components: segment config
+   * doesn't decide what renders dynamically there, so an automatic prefetch of
+   * a dynamic route without a loading boundary still renders its page
+   * (Next.js prefetches its static shell instead).
+   */
+  rendersDynamically?: true;
+  /**
+   * Intercepting pages that can render a URL of this route under a matching
+   * interception context. Next.js builds each as its own route, so its
+   * `rendersDynamically` replaces the route's own then. Set only alongside
+   * `rendersDynamically` classification.
+   */
+  intercepts?: VinextLinkPrefetchIntercept[];
   requiresDynamicNavigationRequest?: boolean;
   /** The route has dynamic params above its root layout. */
   hasRootParams?: true;
 };
+export type VinextLinkPrefetchIntercept = {
+  /** The URL pattern of the route the interception context must be on, or below. */
+  sourcePatternParts: string[];
+  /** The URL pattern the intercepting page intercepts. */
+  targetPatternParts: string[];
+  rendersDynamically?: true;
+};
 /**
  * Pages Router route pattern exposed to the client so the App Router's
  * navigation runtime can decide whether a soft-navigated URL should be
@@ -49,4 +72,5 @@ type VinextLocaleGlobalTarget = {
 export declare function extractVinextNextDataJson(html: string): string | null;
 export declare function parseVinextNextDataJson(json: string): BrowserVinextNextData;
 export declare function applyVinextLocaleGlobals(target: VinextLocaleGlobalTarget, nextData: VinextNextData): void;
-//#endregion
+//#endregion
+export {};

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

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

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

@@ -55,7 +55,7 @@ export declare function checkHasConditions(has: HasCondition[] | undefined, miss
  */
 export type RedirectMatch = {
   destination: string;
-  permanent: boolean;
+  statusCode: number;
   destinationQuery: RedirectDestinationQueryPart[];
 };
 /**
@@ -157,6 +157,17 @@ export declare function sanitizeDestination(dest: string): string;
  * https://github.com/vercel/next.js/blob/canary/packages/next/src/server/server-route-utils.ts
  */
 export declare function preserveRedirectDestinationQuery(destination: string, requestSearch: string, destinationQuery?: RedirectDestinationQueryPart[]): string;
+/**
+ * Percent-encode what a config-redirect `Location` header cannot carry.
+ *
+ * The destination template was already parsed like a URL by matchRedirect, so
+ * its literal path, hash and host are encoded as Next.js sends them. Captures
+ * and the destination query are inserted verbatim, like Next.js, so they can
+ * still hold control or non-ASCII characters. Next.js writes those raw and its
+ * Node server answers 500 for a character above U+00FF (the Headers
+ * constructor throws the same way); vinext percent-encodes them instead.
+ */
+export declare function encodeRedirectLocation(location: string): string;
 /**
  * Proxy an incoming request to an external URL and return the upstream response.
  *

package/dist/config/config-matchers.js

@@ -388,10 +388,13 @@ function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAU
 			onRuleSourceMatch?.(redirect);
 			const conditionParams = redirect.has || redirect.missing ? collectConditionParams(redirect.has, redirect.missing, ctx) : _emptyParams();
 			if (!conditionParams) continue;
-			localeMatch = resolveRedirectMatch(redirect, {
-				[entry.paramName]: "",
-				...conditionParams
-			});
+			localeMatch = {
+				redirect,
+				params: {
+					[entry.paramName]: "",
+					...conditionParams
+				}
+			};
 			localeMatchIndex = entry.originalIndex;
 			break;
 		}
@@ -408,10 +411,13 @@ function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAU
 				onRuleSourceMatch?.(redirect);
 				const conditionParams = redirect.has || redirect.missing ? collectConditionParams(redirect.has, redirect.missing, ctx) : _emptyParams();
 				if (!conditionParams) continue;
-				localeMatch = resolveRedirectMatch(redirect, {
-					[entry.paramName]: localePart,
-					...conditionParams
-				});
+				localeMatch = {
+					redirect,
+					params: {
+						[entry.paramName]: localePart,
+						...conditionParams
+					}
+				};
 				localeMatchIndex = entry.originalIndex;
 				break;
 			}
@@ -428,10 +434,10 @@ function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAU
 			return resolveRedirectMatch(redirect, {
 				...params,
 				...conditionParams
-			});
+			}, basePathState);
 		}
 	}
-	return localeMatch;
+	return localeMatch && resolveRedirectMatch(localeMatch.redirect, localeMatch.params, basePathState);
 }
 /**
 * Apply rewrite rules from next.config.js.
@@ -492,11 +498,83 @@ function matchesRewriteSource(pathname, rewrite, basePathState = _BASEPATH_DEFAU
 function substituteAndSanitizeDestination(destination, params, kind) {
 	return sanitizeDestination(substituteDestinationParams(destination, params, kind));
 }
-function resolveRedirectMatch(redirect, params) {
+/**
+* Prepare a redirect destination template as Next.js does before substituting
+* params. processRoutes (load-custom-routes.ts) prefixes a local destination
+* with the basePath (a bare `/` becomes the basePath, except on the
+* default-locale variant), then parseDestination (prepare-destination.ts) parses it
+* with the URL parser, its param tokens escaped so they survive. This trims
+* whitespace, resolves dot segments and backslashes, percent-encodes the path
+* and hash, punycodes the host, drops an empty query or hash, and throws (a
+* 500) on an invalid absolute URL. Captures are substituted afterwards, so the
+* parser never sees them. The query text is kept verbatim, as
+* preserveRedirectDestinationQuery emits it.
+*/
+function parseRedirectDestinationTemplate(redirect, params, { basePath, hadBasePath }) {
+	let template = redirect.destination;
+	const isLocal = template.startsWith("/");
+	if (isLocal && basePath && hadBasePath) template = template === "/" && !redirect.defaultLocaleVariant ? basePath : basePath + template;
+	template = template.replace(LOCATION_STRIPPED_RE, "");
+	let marker = "__ESC_COLON_";
+	while (template.toLowerCase().includes(marker.toLowerCase())) marker = `_${marker}`;
+	const paramValues = Object.values(params);
+	let literalColon = "__ESC_LITERAL_COLON_";
+	while (template.includes(literalColon) || paramValues.some((value) => value.includes(literalColon))) literalColon = `_${literalColon}`;
+	const keys = Object.keys(params).sort((a, b) => b.length - a.length);
+	const keyPattern = keys.map((key) => key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+	const escaped = keys.length === 0 ? template : template.replace(new RegExp(`\\\\.|:(${keyPattern})(?![A-Za-z0-9_])`, "gs"), (match, key) => key ? `${marker}${key}` : match);
+	const consumeEscapes = (value) => value.replace(/\\(.)/gs, (_, char) => char === ":" ? literalColon : char);
+	let url;
+	try {
+		url = isLocal ? new URL(`http://n${escaped}`) : new URL(escaped);
+	} catch {
+		return {
+			template,
+			literalColon,
+			parsed: false
+		};
+	}
+	const hash = url.hash;
+	url.search = "";
+	url.hash = "";
+	const hashIndex = template.indexOf("#");
+	const beforeHash = hashIndex === -1 ? template : template.slice(0, hashIndex);
+	const queryIndex = beforeHash.indexOf("?");
+	const query = queryIndex === -1 ? "" : beforeHash.slice(queryIndex);
+	let base = isLocal ? url.pathname : url.href;
+	if (!isLocal && (url.username || url.password)) {
+		const auth = url.username ? `${encodeURIComponent(url.password ? `${url.username}:${url.password}` : url.username).replace(/%3A/i, ":")}@` : "";
+		url.username = "";
+		url.password = "";
+		base = url.href.replace("//", `//${auth}`);
+	}
+	if (!isLocal && !SPECIAL_SCHEME_RE.test(url.protocol)) base = base.slice(0, base.length - url.pathname.length) + consumeEscapes(url.pathname);
+	const markerRe = new RegExp(`${marker}(${keyPattern})`, "gi");
+	const unescape = (value) => keys.length === 0 ? value : value.replace(markerRe, (_, key) => `:${keys.includes(key) ? key : keys.find((k) => k.toLowerCase() === key.toLowerCase())}`);
+	return {
+		template: `${unescape(base)}${/^\?&*$/.test(query) ? "" : query}${unescape(consumeEscapes(hash))}`,
+		literalColon,
+		parsed: true
+	};
+}
+const SPECIAL_SCHEME_RE = /^(?:https?|wss?|ftp|file):$/;
+const REDIRECT_ORIGIN_RE = /^[A-Za-z][A-Za-z0-9+.-]*:\/\/[^/?#]*/;
+/**
+* Next.js resolve-routes.ts runs normalizeRepeatedSlashes on the prepared
+* destination's pathname, after params are substituted: backslashes become
+* `/` and runs of slashes collapse, so a basePath-prefixed `//target`
+* becomes `/docs/target`. `destination` starts at the pathname.
+*/
+function normalizeRedirectPathnameSlashes(destination) {
+	return destination.replace(/^[^?#]*/, (pathname) => pathname.replace(/\\/g, "/").replace(/\/\/+/g, "/"));
+}
+function resolveRedirectMatch(redirect, params, basePathState) {
+	const { template: destination, literalColon, parsed } = parseRedirectDestinationTemplate(redirect, params, basePathState);
+	const origin = REDIRECT_ORIGIN_RE.exec(destination)?.[0] ?? "";
 	return {
-		destination: substituteAndSanitizeDestination(redirect.destination, params, "redirect"),
-		permanent: redirect.permanent,
-		destinationQuery: substituteRedirectDestinationQuery(redirect.destination, params)
+		destination: (!parsed ? substituteAndSanitizeDestination(destination, params, "redirect") : origin ? substituteDestinationParams(origin, params, "redirect") + normalizeRedirectPathnameSlashes(substituteDestinationParams(destination.slice(origin.length), params, "redirect")) : normalizeRedirectPathnameSlashes(substituteAndSanitizeDestination(destination, params, "redirect"))).replaceAll(literalColon, ":"),
+		statusCode: redirect.statusCode || (redirect.permanent ? 308 : 307),
+		destinationQuery: substituteRedirectDestinationQuery(destination, params)
 	};
 }
 /**
@@ -639,6 +717,22 @@ function preserveRedirectDestinationQuery(destination, requestSearch, destinatio
 	}).flat().join("&");
 	return mergedQuery === "" ? `${pathPart}${hash}` : `${pathPart}?${mergedQuery}${hash}`;
 }
+const LOCATION_STRIPPED_RE = /^[\u0000- ]+|[\u0000- ]+$|[\t\n\r]/g;
+const LOCATION_UNSAFE_RE = /[\u0000-\u0008\u000A-\u001F\u007F]|[^\u0000-\u007F]/gu;
+const LONE_SURROGATE_RE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g;
+/**
+* Percent-encode what a config-redirect `Location` header cannot carry.
+*
+* The destination template was already parsed like a URL by matchRedirect, so
+* its literal path, hash and host are encoded as Next.js sends them. Captures
+* and the destination query are inserted verbatim, like Next.js, so they can
+* still hold control or non-ASCII characters. Next.js writes those raw and its
+* Node server answers 500 for a character above U+00FF (the Headers
+* constructor throws the same way); vinext percent-encodes them instead.
+*/
+function encodeRedirectLocation(location) {
+	return location.replace(LONE_SURROGATE_RE, "�").replace(LOCATION_UNSAFE_RE, encodeURIComponent);
+}
 function parseExternalRewriteUrl(externalUrl) {
 	try {
 		return new URL(externalUrl);
@@ -901,7 +995,8 @@ function applyLocaleToRoutes(routes, i18n, type, options = {}) {
 			const localizedSource = `/${locale}${suffixFor(r.source)}`;
 			out.push({
 				...r,
-				source: localizedSource
+				source: localizedSource,
+				...type === "redirect" ? { defaultLocaleVariant: true } : {}
 			});
 		}
 		const internalSource = `${internalLocale}${suffixFor(r.source)}`;
@@ -918,4 +1013,4 @@ function applyLocaleToRoutes(routes, i18n, type, options = {}) {
 	return out;
 }
 //#endregion
-export { applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, configSourceError, isExternalUrl, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, matchesRewriteSource, normalizeHost, parseCookies, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, sanitizeDestination };
+export { applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, configSourceError, encodeRedirectLocation, isExternalUrl, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, matchesRewriteSource, normalizeHost, parseCookies, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, sanitizeDestination };

package/dist/config/dotenv.d.ts

@@ -47,4 +47,5 @@ export declare function getDotenvFiles(mode: string): string[];
  * commands (which don't go through Vite at all), this is the only loading.
  */
 export declare function loadDotenv({ root, mode, processEnv }: LoadDotenvOptions): LoadDotenvResult;
-//#endregion
+//#endregion
+export {};

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

@@ -18,7 +18,13 @@ export type HasCondition = {
 export type NextRedirect = {
   source: string;
   destination: string;
-  permanent: boolean;
+  /** `true` answers 308, `false` 307. Ignored when `statusCode` is set. */
+  permanent?: boolean;
+  /**
+   * Explicit redirect status, taking precedence over `permanent` as in Next.js
+   * `getRedirectStatus` (lib/redirect-status.ts).
+   */
+  statusCode?: 301 | 302 | 303 | 307 | 308;
   has?: HasCondition[];
   missing?: HasCondition[];
   /**
@@ -36,6 +42,12 @@ export type NextRedirect = {
    * `.nextjs-ref/packages/next/src/lib/load-custom-routes.ts:26`.
    */
   basePath?: false;
+  /**
+   * Internal: set by `applyLocaleToRoutes` on the `/${defaultLocale}` variant.
+   * Next.js `processRoutes` prefixes that variant's destination with the
+   * basePath without turning a bare `/` into the bare basePath.
+   */
+  defaultLocaleVariant?: true;
 };
 export type NextRewrite = {
   source: string;
@@ -90,6 +102,18 @@ export type MdxOptions = {
   rehypePlugins?: unknown[];
   recmaPlugins?: unknown[];
 };
+/**
+ * The webpack/Turbopack rule `createNextIntlPlugin` adds for its
+ * `experimental.messages` catalogs. vinext runs the same loader on the files it matches.
+ */
+export type NextIntlCatalogLoader = {
+  /** Absolute catalog directories (the rule's `include`). */
+  include: string[];
+  /** Catalog file extension test (the rule's `test`). */
+  test: RegExp;
+  /** The loader's `options`. */
+  options: Record<string, unknown>;
+};
 export type PrefetchInliningConfig = false | {
   maxBundleSize: number;
   maxSize: number;
@@ -340,6 +364,11 @@ export type ResolvedNextConfig = {
   /** Server globals injected into instrumentation.ts by wrapped webpack configs. */
   instrumentationServerValueInjections: Record<string, unknown>;
   cacheComponents: boolean;
+  /**
+   * `experimental.cachedNavigations`: lets the client cache the static stage of
+   * navigation responses. Requires `cacheComponents`.
+   */
+  cachedNavigations: boolean;
   appNavFailHandling: boolean;
   /**
    * Enables the experimental App Router gesture transition API:
@@ -362,6 +391,8 @@ export type ResolvedNextConfig = {
   i18n: NextI18nConfig | null;
   /** MDX remark/rehype/recma plugins extracted from @next/mdx config */
   mdx: MdxOptions | null;
+  /** next-intl's message catalog loader rule from `createNextIntlPlugin`. */
+  nextIntlCatalogLoader: NextIntlCatalogLoader | null;
   /** Explicit module aliases preserved from wrapped next.config plugins. */
   aliases: Record<string, string>;
   /** Extra allowed origins for dev server access (from allowedDevOrigins). */