vinext 1.2.1 → 1.3.1

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

@@ -0,0 +1,34 @@
+import { PathKey } from "../utils/path-to-regexp.js";
+//#region src/config/config-source.d.ts
+export type CompiledConfigSource = {
+  re: RegExp;
+  /** Keys in capture-group order; unnamed groups have numeric names. */
+  keys: PathKey[];
+};
+/**
+ * Why `source` is not a valid redirects/rewrites/headers source, or null.
+ * Mirrors the source checks in Next.js's checkCustomRoutes, which fail the
+ * build; config loading calls this to do the same.
+ *
+ * https://github.com/vercel/next.js/blob/v16.2.7/packages/next/src/lib/load-custom-routes.ts
+ */
+export declare function configSourceError(source: unknown): string | null;
+export declare function compileConfigSource(source: string): CompiledConfigSource | null;
+/**
+ * Match a Next.js config source (from redirects/rewrites/headers) against a
+ * pathname. Returns the named params or null.
+ *
+ * Unnamed groups are dropped, as Next.js does with `removeUnnamedParams`.
+ * Repeated params (`:path*`, `:path+`) keep the captured string (`a/b`), and
+ * an optional param that did not match is `""`.
+ */
+export declare function matchConfigPattern(pathname: string, pattern: string): Record<string, string> | null;
+/**
+ * matchConfigPattern, also reporting the optional params that did not match.
+ * Next.js leaves those out of its params entirely.
+ */
+export declare function execConfigSource(pathname: string, source: string): {
+  params: Record<string, string>;
+  unmatched: string[];
+} | null;
+//#endregion

package/dist/config/config-source.js

@@ -0,0 +1,141 @@
+import { normalizePathTokens, parsePathPattern, pathTokensToRegExpSource } from "../utils/path-to-regexp.js";
+//#region src/config/config-source.ts
+/**
+* Compiles and matches next.config.js redirect, rewrite and header sources.
+*
+* Kept apart from config-matchers so the Pages router can match sources
+* synchronously with the same code as the server, without bundling the rest
+* of config-matchers.
+*/
+/**
+* Cache for compiled redirect/rewrite/header sources.
+*
+* Sources come from next.config.js and never change at runtime. Without
+* caching, every request re-parses and recompiles every rule. On apps with
+* many locale-prefixed rules this dominated profiling at ~2.4 seconds of CPU
+* self-time.
+*
+* Value is `null` when the source is invalid, so we skip it on subsequent
+* requests too without re-parsing it.
+*/
+const _compiledSourceCache = /* @__PURE__ */ new Map();
+/**
+* Compile a redirect/rewrite/header source the way Next.js does at runtime:
+* path-to-regexp 6 with `strict: true`, `delimiter: "/"` and case-insensitive
+* matching, then `modifyRouteRegex` appends an optional trailing slash.
+*
+* Returns an error for sources path-to-regexp rejects. Like Next.js, custom
+* param patterns are not checked for catastrophic backtracking.
+*
+* https://github.com/vercel/next.js/blob/v16.2.7/packages/next/src/server/lib/router-utils/filesystem.ts
+* https://github.com/vercel/next.js/blob/v16.2.7/packages/next/src/shared/lib/router/utils/path-match.ts
+*/
+function compileConfigSourceUncached(source) {
+	const parsed = parseConfigSource(source);
+	if ("kind" in parsed) return parsed;
+	const { tokens, re } = parsed;
+	return {
+		re,
+		keys: tokens.filter((token) => typeof token !== "string" && !!token.pattern)
+	};
+}
+function parseConfigSource(source) {
+	try {
+		const tokens = parsePathPattern(source, { delimiter: "/" });
+		return {
+			tokens,
+			re: new RegExp(`${pathTokensToRegExpSource(tokens)}(?:\\/)?$`, "i")
+		};
+	} catch (error) {
+		return {
+			kind: "invalid",
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+/**
+* Length of the RegExp Next.js builds when validating a source
+* (tryToParsePath: path-to-regexp defaults, retried with normalized repeat
+* tokens), or null when it cannot be built.
+*/
+function validationRegExpLength(source) {
+	try {
+		const tokens = parsePathPattern(source);
+		const build = (value) => new RegExp(`${pathTokensToRegExpSource(value)}[\\/#\\?]?$`).source.length;
+		try {
+			return build(tokens);
+		} catch {
+			return build(normalizePathTokens(tokens));
+		}
+	} catch {
+		return null;
+	}
+}
+/**
+* Why `source` is not a valid redirects/rewrites/headers source, or null.
+* Mirrors the source checks in Next.js's checkCustomRoutes, which fail the
+* build; config loading calls this to do the same.
+*
+* https://github.com/vercel/next.js/blob/v16.2.7/packages/next/src/lib/load-custom-routes.ts
+*/
+function configSourceError(source) {
+	if (!source) return "`source` is missing";
+	if (typeof source !== "string") return "`source` is not a string";
+	if (!source.startsWith("/")) return "`source` does not start with /";
+	const parsed = parseConfigSource(source);
+	if ("kind" in parsed) return parsed.error;
+	const length = validationRegExpLength(source);
+	if (length !== null && length > 4096) return "`source` exceeds max built length of 4096";
+	return null;
+}
+function compileConfigSource(source) {
+	let compiled = _compiledSourceCache.get(source);
+	if (compiled !== void 0) return compiled;
+	const result = compileConfigSourceUncached(source);
+	if ("kind" in result) {
+		console.warn(`[vinext] Ignoring invalid next.config.js source "${source}": ${result.error}`);
+		compiled = null;
+	} else compiled = result;
+	_compiledSourceCache.set(source, compiled);
+	return compiled;
+}
+/**
+* Match a Next.js config source (from redirects/rewrites/headers) against a
+* pathname. Returns the named params or null.
+*
+* Unnamed groups are dropped, as Next.js does with `removeUnnamedParams`.
+* Repeated params (`:path*`, `:path+`) keep the captured string (`a/b`), and
+* an optional param that did not match is `""`.
+*/
+function matchConfigPattern(pathname, pattern) {
+	return execConfigSource(pathname, pattern)?.params ?? null;
+}
+/**
+* matchConfigPattern, also reporting the optional params that did not match.
+* Next.js leaves those out of its params entirely.
+*/
+function execConfigSource(pathname, source) {
+	const compiled = compileConfigSource(source);
+	if (!compiled) return null;
+	const match = compiled.re.exec(pathname);
+	if (!match) return null;
+	const params = Object.create(null);
+	const matched = /* @__PURE__ */ new Set();
+	for (let i = 0; i < compiled.keys.length; i++) {
+		const key = compiled.keys[i].name;
+		if (typeof key !== "string") continue;
+		const value = match[i + 1];
+		if (value === void 0) {
+			if (!matched.has(key)) params[key] = "";
+			continue;
+		}
+		matched.add(key);
+		params[key] = value;
+	}
+	return {
+		params,
+		unmatched: Object.keys(params).filter((key) => !matched.has(key))
+	};
+}
+//#endregion
+export { compileConfigSource, configSourceError, execConfigSource, matchConfigPattern };

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/header-params.d.ts

@@ -0,0 +1,29 @@
+//#region src/config/header-params.d.ts
+/**
+ * Param substitution for next.config.js `headers()` keys and values.
+ *
+ * Next.js compiles each header key and value with `compileNonPath`: only
+ * `:name` markers for captured params are substituted, every other
+ * path-to-regexp metacharacter stays literal, repeated params are joined with
+ * their template prefix and suffix, and params are inserted verbatim (no
+ * encoding or validation).
+ *
+ * https://github.com/vercel/next.js/blob/v16.2.7/packages/next/src/shared/lib/router/utils/prepare-destination.ts
+ * https://github.com/vercel/next.js/blob/v16.2.7/packages/next/src/shared/lib/router/utils/route-match-utils.ts
+ */
+/**
+ * Params captured by a header rule: path-to-regexp source params (`*`/`+`
+ * params are arrays) merged with Next.js `matchHas` captures. A has capture
+ * can be `undefined` when its named group did not participate in the match.
+ */
+export type HeaderParams = Record<string, string | string[] | undefined>;
+/**
+ * Substitute `params` into a header key or value like Next.js's
+ * `compileNonPath`. Throws where Next.js throws: a repeated param referenced
+ * without `*`/`+`, an `undefined` has capture, or a template path-to-regexp
+ * cannot parse.
+ */
+export declare function compileHeaderParamTemplate(value: string, params: HeaderParams): string;
+/** Whether a substituted header pair can be sent as a response header. */
+export declare function isValidHeaderPair(key: string, value: string): boolean;
+//#endregion

package/dist/config/header-params.js

@@ -0,0 +1,106 @@
+import { parsePathPattern } from "../utils/path-to-regexp.js";
+//#region src/config/header-params.ts
+/**
+* Param substitution for next.config.js `headers()` keys and values.
+*
+* Next.js compiles each header key and value with `compileNonPath`: only
+* `:name` markers for captured params are substituted, every other
+* path-to-regexp metacharacter stays literal, repeated params are joined with
+* their template prefix and suffix, and params are inserted verbatim (no
+* encoding or validation).
+*
+* https://github.com/vercel/next.js/blob/v16.2.7/packages/next/src/shared/lib/router/utils/prepare-destination.ts
+* https://github.com/vercel/next.js/blob/v16.2.7/packages/next/src/shared/lib/router/utils/route-match-utils.ts
+*/
+/**
+* Substitute `params` into a header key or value like Next.js's
+* `compileNonPath`. Throws where Next.js throws: a repeated param referenced
+* without `*`/`+`, an `undefined` has capture, or a template path-to-regexp
+* cannot parse.
+*/
+function compileHeaderParamTemplate(value, params) {
+	if (!value.includes(":")) return value;
+	const keys = Object.keys(params);
+	const cacheKey = JSON.stringify([value, keys]);
+	let compiled = _compiledTemplateCache.get(cacheKey);
+	if (!compiled) {
+		try {
+			compiled = { compile: compileTemplate(value, keys) };
+		} catch (error) {
+			compiled = { error };
+		}
+		_compiledTemplateCache.set(cacheKey, compiled);
+	}
+	if ("error" in compiled) throw compiled.error;
+	return compiled.compile(params);
+}
+const _compiledTemplateCache = /* @__PURE__ */ new Map();
+function compileTemplate(value, keys) {
+	for (const key of keys) if (value.includes(`:${key}`)) value = value.replace(new RegExp(`:${key}\\*`, "g"), `:${key}--ESCAPED_PARAM_ASTERISKS`).replace(new RegExp(`:${key}\\?`, "g"), `:${key}--ESCAPED_PARAM_QUESTION`).replace(new RegExp(`:${key}\\+`, "g"), `:${key}--ESCAPED_PARAM_PLUS`).replace(new RegExp(`:${key}(?!\\w)`, "g"), `--ESCAPED_PARAM_COLON${key}`);
+	value = value.replace(/(:|\*|\?|\+|\(|\)|\{|\})/g, "\\$1").replace(/--ESCAPED_PARAM_PLUS/g, "+").replace(/--ESCAPED_PARAM_COLON/g, ":").replace(/--ESCAPED_PARAM_QUESTION/g, "?").replace(/--ESCAPED_PARAM_ASTERISKS/g, "*");
+	const compiler = safeCompile(`/${value}`);
+	return (params) => compiler(params).slice(1);
+}
+const PARAM_SEPARATOR = "_NEXTSEP_";
+function safeCompile(route) {
+	const needsNormalization = /\/\(\.{1,3}\):[^/\s]+/.test(route) || ADJACENT_PARAMS_RE.test(route);
+	const routeToUse = needsNormalization ? normalizeAdjacentParameters(route) : route;
+	try {
+		const compiler = compile(routeToUse);
+		return needsNormalization ? (params) => stripNormalizedSeparators(compiler(params)) : compiler;
+	} catch (error) {
+		if (needsNormalization) throw error;
+		try {
+			const compiler = compile(normalizeAdjacentParameters(route));
+			return (params) => stripNormalizedSeparators(compiler(params));
+		} catch {
+			throw error;
+		}
+	}
+}
+const ADJACENT_PARAMS_RE = /:[a-zA-Z_][a-zA-Z0-9_]*:[a-zA-Z_][a-zA-Z0-9_]*/;
+function normalizeAdjacentParameters(route) {
+	return route.replace(/(\([^)]*\)):([^/\s]+)/g, `$1${PARAM_SEPARATOR}:$2`).replace(/:([^:/\s)]+)(?=:)/g, `:$1${PARAM_SEPARATOR}`);
+}
+function stripNormalizedSeparators(pathname) {
+	return pathname.replace(new RegExp(`\\)${PARAM_SEPARATOR}`, "g"), ")");
+}
+function compile(route) {
+	const tokens = parsePathPattern(route);
+	return (params) => {
+		let path = "";
+		for (const token of tokens) {
+			if (typeof token === "string") {
+				path += token;
+				continue;
+			}
+			const value = params[token.name];
+			const optional = token.modifier === "?" || token.modifier === "*";
+			const repeat = token.modifier === "*" || token.modifier === "+";
+			if (Array.isArray(value)) {
+				if (!repeat) throw new TypeError(`Expected "${token.name}" to not repeat, but got an array`);
+				if (value.length === 0) {
+					if (optional) continue;
+					throw new TypeError(`Expected "${token.name}" to not be empty`);
+				}
+				for (const segment of value) path += token.prefix + segment + token.suffix;
+				continue;
+			}
+			if (typeof value === "string") {
+				path += token.prefix + value + token.suffix;
+				continue;
+			}
+			if (optional) continue;
+			throw new TypeError(`Expected "${token.name}" to be ${repeat ? "an array" : "a string"}`);
+		}
+		return path;
+	};
+}
+const HTTP_TOKEN_RE = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/;
+const INVALID_HEADER_VALUE_CHAR_RE = /[^\t\x20-\x7e\x80-\xff]/;
+/** Whether a substituted header pair can be sent as a response header. */
+function isValidHeaderPair(key, value) {
+	return HTTP_TOKEN_RE.test(key) && !INVALID_HEADER_VALUE_CHAR_RE.test(value);
+}
+//#endregion
+export { compileHeaderParamTemplate, isValidHeaderPair };

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;
@@ -609,11 +621,13 @@ export declare function normalizeAssetPrefix(value: unknown): string;
 /**
  * Resolve the App Router RSC compatibility identity for a build.
  *
- * This token is baked into the client bundle and echoed by the server in the
- * `X-Vinext-RSC-Compatibility-Id` response header; browser navigation rejects
- * RSC payloads whose token differs (deploy skew) without exposing the raw
- * build ID. When the user pins a `deploymentId` we reuse it (already stable
- * across plugin instances); otherwise we mint a random UUID.
+ * The server sends this token with each page (the navigation bootstrap) and in
+ * the `X-Vinext-RSC-Compatibility-Id` response header; browser navigation
+ * rejects RSC payloads whose token differs from its page's (deploy skew)
+ * without exposing the raw build ID. It is never inlined into the client
+ * bundle, where a per-build value would rename chunks on every build. When
+ * the user pins a `deploymentId` we reuse it (already stable across plugin
+ * instances); otherwise we mint a random UUID.
  *
  * NOTE: like `resolveBuildId`, this is non-deterministic in the no-deploymentId
  * case, so a single `vite build` that instantiates the plugin more than once

package/dist/config/next-config.js

@@ -5,6 +5,7 @@ import { isUnknownRecord } from "../utils/record.js";
 import { PHASE_DEVELOPMENT_SERVER, PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
 import { getHtmlLimitedBotRegex } from "../utils/html-limited-bots.js";
 import { flattenPluginOptions } from "../utils/plugin-options.js";
+import { configSourceError } from "./config-source.js";
 import { isExternalUrl } from "../utils/external-url.js";
 import { applyLocaleToRoutes } from "./config-matchers.js";
 import { loadTsconfigResolutionForRoot } from "./tsconfig-paths.js";
@@ -373,7 +374,8 @@ function warnDeprecatedConfigOptions(config, root) {
 		["experimental.instrumentationHook", `\`experimental.instrumentationHook\` is no longer needed, because \`instrumentation.js\` is available by default. You can remove it from ${configFileName}.`]
 	];
 	for (const [propertyPath, warning] of warnings) if (hasConfigProperty(config, propertyPath)) warnConfigOnce(warning);
-	if (readOptionalRecord(config.experimental)?.skipTrailingSlashRedirect != null) warnConfigOnce(`\`experimental.skipTrailingSlashRedirect\` has been moved to \`skipTrailingSlashRedirect\`. Please update your ${configFileName} file accordingly.`);
+	const experimental = readOptionalRecord(config.experimental);
+	for (const key of ["skipTrailingSlashRedirect", "cacheComponents"]) if (experimental?.[key] != null) warnConfigOnce(`\`experimental.${key}\` has been moved to \`${key}\`. Please update your ${configFileName} file accordingly.`);
 }
 async function resolveNextConfigInput(config, phase = PHASE_DEVELOPMENT_SERVER) {
 	return await resolveConfigValue(config, phase);
@@ -534,11 +536,13 @@ function resolveDeploymentId(configDeploymentId) {
 /**
 * Resolve the App Router RSC compatibility identity for a build.
 *
-* This token is baked into the client bundle and echoed by the server in the
-* `X-Vinext-RSC-Compatibility-Id` response header; browser navigation rejects
-* RSC payloads whose token differs (deploy skew) without exposing the raw
-* build ID. When the user pins a `deploymentId` we reuse it (already stable
-* across plugin instances); otherwise we mint a random UUID.
+* The server sends this token with each page (the navigation bootstrap) and in
+* the `X-Vinext-RSC-Compatibility-Id` response header; browser navigation
+* rejects RSC payloads whose token differs from its page's (deploy skew)
+* without exposing the raw build ID. It is never inlined into the client
+* bundle, where a per-build value would rename chunks on every build. When
+* the user pins a `deploymentId` we reuse it (already stable across plugin
+* instances); otherwise we mint a random UUID.
 *
 * NOTE: like `resolveBuildId`, this is non-deterministic in the no-deploymentId
 * case, so a single `vite build` that instantiates the plugin more than once
@@ -750,6 +754,115 @@ function normalizeI18nConfig(value) {
 	};
 }
 /**
+* Fail config loading on an invalid source, as Next.js fails the build
+* (load-custom-routes.ts checkCustomRoutes), instead of silently skipping a
+* redirect or security header per request.
+*/
+function validateConfigSources(type, routes) {
+	const invalid = [];
+	for (const route of routes) {
+		const error = configSourceError(route?.source);
+		if (!error) continue;
+		invalid.push(`  ${describeSource(route?.source)}: ${error}`);
+	}
+	if (invalid.length > 0) throw new Error(`Invalid next.config.js ${type} source${invalid.length === 1 ? "" : "s"}:\n${invalid.join("\n")}`);
+}
+/**
+* A route source for an error message. Only a string is shown as is; any
+* other value, such as a BigInt, may not serialize.
+*/
+function describeSource(source) {
+	return typeof source === "string" ? JSON.stringify(source) : `(${source === null ? "null" : typeof source})`;
+}
+const CONDITION_TYPES = /* @__PURE__ */ new Set([
+	"header",
+	"cookie",
+	"query",
+	"host"
+]);
+/**
+* Fail config loading on a malformed has/missing list or item, with the rules
+* of Next.js's checkCustomRoutes (load-custom-routes.ts). The matchers rely on
+* these shapes.
+*/
+function validateConfigConditions(type, routes) {
+	const invalid = [];
+	for (const route of routes) {
+		const source = describeSource(route?.source);
+		for (const field of ["has", "missing"]) {
+			const items = route?.[field];
+			if (items === void 0) continue;
+			if (!Array.isArray(items)) {
+				invalid.push(`  ${source}: \`${field}\` must be undefined or an array`);
+				continue;
+			}
+			for (const item of items) {
+				const condition = item ?? {};
+				const parts = [];
+				if (!CONDITION_TYPES.has(condition.type)) parts.push("invalid type");
+				if (typeof condition.key !== "string" && condition.type !== "host") parts.push("invalid key");
+				if (condition.value !== void 0 && typeof condition.value !== "string") parts.push("invalid value");
+				if (condition.value === void 0 && condition.type === "host") parts.push("value is required for \"host\" type");
+				if (parts.length > 0) invalid.push(`  ${source}: \`${field}\` item: ${parts.join(", ")} for ${describeConfigValue(item)}`);
+			}
+		}
+	}
+	if (invalid.length > 0) throw new Error(`Invalid next.config.js ${type} has/missing condition${invalid.length === 1 ? "" : "s"}:\n${invalid.join("\n")}\nEach item must be { type: header, cookie, query or host, key: string, value?: string }, with a value and no key required for host.`);
+}
+const REDIRECT_STATUS_CODES = /* @__PURE__ */ new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
+/**
+* Fail config loading on a redirect without a valid status, with the rules of
+* Next.js's checkRedirect (load-custom-routes.ts): `statusCode` must be one of
+* the redirect statuses, and `permanent` a boolean when it is absent.
+*/
+function validateRedirectStatuses(redirects) {
+	const invalid = [];
+	for (const redirect of redirects) {
+		const parts = [];
+		if (redirect.statusCode && !REDIRECT_STATUS_CODES.has(redirect.statusCode)) parts.push("`statusCode` is not undefined or valid statusCode");
+		if (typeof redirect.permanent !== "boolean" && !redirect.statusCode) parts.push("`permanent` is not set to `true` or `false`");
+		if (parts.length > 0) invalid.push(`  ${describeSource(redirect.source)}: ${parts.join(", ")}`);
+	}
+	if (invalid.length > 0) throw new Error(`Invalid next.config.js redirect${invalid.length === 1 ? "" : "s"}:\n${invalid.join("\n")}\nValid redirect statusCode values are ${[...REDIRECT_STATUS_CODES].join(", ")}`);
+}
+/** JSON for a config value, or its type when JSON cannot serialize it. */
+function describeConfigValue(value) {
+	try {
+		return JSON.stringify(value) ?? `(${typeof value})`;
+	} catch {
+		return `(${typeof value})`;
+	}
+}
+/**
+* The sources Next.js's processRoutes builds from `routes` by adding the
+* basePath and locale prefixes, which checkCustomRoutes then checks again
+* (load-custom-routes.ts). vinext adds basePath at match time instead, so
+* these exist only for that check.
+*/
+function processedRouteSources(routes, type, options) {
+	const { basePath, i18n, trailingSlash } = options;
+	const escape = (value) => value.replace(/[|\\{}()[\]^$+*?.-]/g, "\\$&");
+	const suffixFor = (source) => source === "/" && !trailingSlash ? "" : source;
+	const defaultLocales = i18n && type === "redirect" ? [...(i18n.domains ?? []).map((domain) => domain.defaultLocale), i18n.defaultLocale] : [];
+	const sources = [];
+	for (const route of routes) {
+		const sourceBasePath = basePath && route.basePath !== false ? basePath : "";
+		let source = route.source;
+		if (i18n && route.locale !== false) {
+			if ("destination" in route && route.destination?.startsWith("/")) for (const locale of defaultLocales) sources.push({ source: `${sourceBasePath}/${locale}${suffixFor(source)}` });
+			source = `/:nextInternalLocale(${i18n.locales.map(escape).join("|")})${suffixFor(source)}`;
+		}
+		sources.push({ source: `${sourceBasePath}${source === "/" && sourceBasePath ? "" : source}` });
+	}
+	return sources;
+}
+/**
 * Resolve a NextConfig into a fully-resolved ResolvedNextConfig.
 * Awaits async functions for redirects/rewrites/headers.
 */
@@ -852,11 +965,19 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 		};
 	}
 	{
-		const externalRewrites = [
+		const allRewrites = [
 			...rewrites.beforeFiles,
 			...rewrites.afterFiles,
 			...rewrites.fallback
-		].filter((rewrite) => isExternalUrl(rewrite.destination));
+		];
+		validateConfigSources("redirect", redirects);
+		validateConfigSources("rewrite", allRewrites);
+		validateConfigConditions("redirect", redirects);
+		validateRedirectStatuses(redirects);
+		validateConfigConditions("rewrite", allRewrites);
+		const invalidBasePathRewrites = allRewrites.filter((rewrite) => rewrite.basePath === false && !(rewrite.destination.startsWith("http://") || rewrite.destination.startsWith("https://")));
+		if (invalidBasePathRewrites.length > 0) throw new Error(invalidBasePathRewrites.map((rewrite) => `The route ${rewrite.source} rewrites urls outside of the basePath. Please use a destination that starts with \`http://\` or \`https://\` https://nextjs.org/docs/messages/invalid-external-rewrite`).concat(`Invalid rewrite${invalidBasePathRewrites.length === 1 ? "" : "s"} found`).join("\n"));
+		const externalRewrites = allRewrites.filter((rewrite) => isExternalUrl(rewrite.destination));
 		if (externalRewrites.length > 0) {
 			const noun = externalRewrites.length === 1 ? "external rewrite" : "external rewrites";
 			const listing = externalRewrites.map((rewrite) => `  ${rewrite.source} → ${rewrite.destination}`).join("\n");
@@ -865,6 +986,22 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 	}
 	let headers = [];
 	if (config.headers) headers = await config.headers();
+	validateConfigSources("header", headers);
+	validateConfigConditions("header", headers);
+	if (config.basePath || i18n) {
+		const processOptions = {
+			basePath: config.basePath ?? "",
+			i18n,
+			trailingSlash: config.trailingSlash ?? false
+		};
+		validateConfigSources("redirect", processedRouteSources(redirects, "redirect", processOptions));
+		validateConfigSources("rewrite", processedRouteSources([
+			...rewrites.beforeFiles,
+			...rewrites.afterFiles,
+			...rewrites.fallback
+		], "rewrite", processOptions));
+		validateConfigSources("header", processedRouteSources(headers, "header", processOptions));
+	}
 	const webpackProbe = await probeWebpackConfig(config, root, options.dev ?? false);
 	const mdx = webpackProbe.mdx;
 	const aliases = {
@@ -873,6 +1010,7 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 	};
 	const allowedDevOrigins = Array.isArray(config.allowedDevOrigins) ? config.allowedDevOrigins : [];
 	const experimental = readOptionalRecord(config.experimental);
+	const cacheComponents = (experimental?.cacheComponents ?? config.cacheComponents) === true;
 	const serverActionsConfig = readOptionalRecord(experimental?.serverActions);
 	const serverActionsAllowedOrigins = readStringArray(serverActionsConfig?.allowedOrigins);
 	const serverActionsBodySizeLimitConfig = readOptionalBodySizeLimit(serverActionsConfig?.bodySizeLimit);
@@ -888,7 +1026,7 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 	const appShells = experimental?.appShells === true;
 	if (appShells) {
 		const missingCoFlags = [];
-		if (!config.cacheComponents) missingCoFlags.push("cacheComponents");
+		if (!cacheComponents) missingCoFlags.push("cacheComponents");
 		if (!prefetchInlining) missingCoFlags.push("experimental.prefetchInlining");
 		if (experimental?.varyParams !== true) missingCoFlags.push("experimental.varyParams");
 		if (experimental?.optimisticRouting !== true) missingCoFlags.push("experimental.optimisticRouting");
@@ -909,7 +1047,7 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 		exclude: lightningCssFeatureNamesToMask(readStringArray(rawLightningCssFeatures?.exclude))
 	};
 	if (rawLightningCssFeatures && !useLightningcss) console.warn("[vinext] experimental.lightningCssFeatures is set but experimental.useLightningcss is not enabled. The lightningCssFeatures option has no effect without useLightningcss.");
-	if (experimental?.cachedNavigations === true && !config.cacheComponents) console.warn("[vinext] `experimental.cachedNavigations` requires `cacheComponents: true` to have any effect. Set `cacheComponents: true` in your next.config, or remove `experimental.cachedNavigations`.");
+	if (experimental?.cachedNavigations === true && !cacheComponents) console.warn("[vinext] `experimental.cachedNavigations` requires `cacheComponents: true` to have any effect. Set `cacheComponents: true` in your next.config, or remove `experimental.cachedNavigations`.");
 	if (config.webpack !== void 0) {
 		if (mdx || Object.keys(webpackProbe.aliases).length > 0 || webpackProbe.resolveExtensionsCustomized || webpackProbe.instrumentationClientRouteManifest !== void 0) console.warn("[vinext] next.config option \"webpack\" is only partially supported. vinext preserves resolve.alias, resolve.extensions, MDX loader settings, and instrumentation-client route manifests, but other webpack customization is ignored");
 		else console.warn("[vinext] next.config option \"webpack\" is not yet supported and will be ignored");
@@ -960,7 +1098,7 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 		instrumentationClientInject: Array.isArray(config.instrumentationClientInject) ? config.instrumentationClientInject.filter((x) => typeof x === "string") : [],
 		instrumentationClientRouteManifest: webpackProbe.instrumentationClientRouteManifest,
 		instrumentationServerValueInjections: webpackProbe.instrumentationServerValueInjections,
-		cacheComponents: config.cacheComponents ?? false,
+		cacheComponents,
 		appNavFailHandling: experimental?.appNavFailHandling === true,
 		gestureTransition: experimental?.gestureTransition === true,
 		prefetchInlining,

package/dist/config/tsconfig-paths.d.ts

@@ -17,4 +17,5 @@ export declare function loadTsconfigResolutionForRoot(projectRoot: string): Tsco
  * Back-compat helper for call sites that only need `compilerOptions.paths`.
  */
 export declare function loadTsconfigPathAliasesForRoot(projectRoot: string): Record<string, string>;
-//#endregion
+//#endregion
+export {};

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/detector.js

@@ -0,0 +1,23 @@
+import { typeHandlers, types } from "./types/index.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/detector.js
+const firstBytes = /* @__PURE__ */ new Map([
+	[0, "heif"],
+	[56, "psd"],
+	[66, "bmp"],
+	[68, "dds"],
+	[71, "gif"],
+	[73, "tiff"],
+	[77, "tiff"],
+	[82, "webp"],
+	[105, "icns"],
+	[137, "png"],
+	[255, "jpg"]
+]);
+function detector(input) {
+	const byte = input[0];
+	const type = firstBytes.get(byte);
+	if (type && typeHandlers.get(type)?.validate(input)) return type;
+	return types.find((type) => typeHandlers.get(type)?.validate(input));
+}
+//#endregion
+export { detector };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/index.js

@@ -0,0 +1,2 @@
+import "./types/index.js";
+export { imageSize } from "./lookup.js";

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/lookup.js

@@ -0,0 +1,25 @@
+import { typeHandlers } from "./types/index.js";
+import { detector } from "./detector.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/lookup.js
+const globalOptions = { disabledTypes: [] };
+function imageSize(input) {
+	const type = detector(input);
+	if (typeof type !== "undefined") {
+		if (globalOptions.disabledTypes.indexOf(type) > -1) throw new TypeError(`disabled file type: ${type}`);
+		const size = typeHandlers.get(type)?.calculate(input);
+		if (size !== void 0) {
+			size.type = size.type ?? type;
+			if (size.images && size.images.length > 1) {
+				const largestImage = size.images.reduce((largest, current) => {
+					return current.width * current.height > largest.width * largest.height ? current : largest;
+				}, size.images[0]);
+				size.width = largestImage.width;
+				size.height = largestImage.height;
+			}
+			return size;
+		}
+	}
+	throw new TypeError(`unsupported file type: ${type}`);
+}
+//#endregion
+export { imageSize };