vinext 0.1.2 → 0.1.4

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.
@@ -267,7 +268,7 @@ function isSafeRegex(pattern) {
 */
 function safeRegExp(pattern, flags) {
 	if (!isSafeRegex(pattern)) {
-		console.warn(`[vinext] Ignoring potentially unsafe regex pattern (ReDoS risk): ${pattern}\n  Patterns with nested quantifiers (e.g. (a+)+) can cause catastrophic backtracking.\n  Simplify the pattern to avoid nested repetition.`);
+		console.warn(`[vinext] Rejecting potentially unsafe regex pattern (ReDoS risk): ${pattern}\n  Patterns with nested quantifiers (e.g. (a+)+) can cause catastrophic backtracking.\n  Simplify the pattern to avoid nested repetition.`);
 		return null;
 	}
 	try {
@@ -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,15 +708,28 @@ 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;
 }
 /**
+* Check whether a rewrite source can match a pathname without evaluating its
+* request-dependent `has` / `missing` conditions.
+*
+* Dev uses this only as a conservative preflight before middleware runs. The
+* conditions may become true after middleware overrides request headers, so
+* evaluating them against the original request would incorrectly skip the
+* Pages request pipeline for file-looking paths.
+*/
+function matchesRewriteSource(pathname, rewrite, basePathState = _BASEPATH_DEFAULT) {
+	return shouldEvaluateRule(rewrite.basePath, basePathState) && matchConfigPattern(pathname, rewrite.source) !== null;
+}
+/**
 * Substitute all matched route params into a redirect/rewrite destination.
 *
 * Handles repeated params (e.g. `/api/:id/:id`) and catch-all suffix forms
@@ -753,6 +758,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
@@ -972,4 +1043,4 @@ function applyLocaleToRoutes(routes, i18n, type, options = {}) {
 	return out;
 }
 //#endregion
-export { applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, escapeHeaderSource, isExternalUrl, isSafeRegex, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, normalizeHost, parseCookies, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, safeRegExp, sanitizeDestination };
+export { applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, escapeHeaderSource, isExternalUrl, isSafeRegex, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, matchesRewriteSource, normalizeHost, parseCookies, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, safeRegExp, sanitizeDestination };

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 };

package/dist/config/next-config.js

@@ -1,10 +1,11 @@
 import { normalizePageExtensions } from "../routing/file-matcher.js";
 import { applyLocaleToRoutes, isExternalUrl } from "./config-matchers.js";
 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 { PHASE_DEVELOPMENT_SERVER, PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
 import { loadTsconfigResolutionForRoot } from "./tsconfig-paths.js";
 import { getViteMajorVersion } from "../utils/vite-version.js";
+import { loadCommonJsModule, shouldRetryAsCommonJs } from "../utils/commonjs-loader.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
 import path from "node:path";
@@ -259,31 +260,16 @@ async function resolveNextConfigInput(config, phase = PHASE_DEVELOPMENT_SERVER)
 *
 * For `.cjs` (or `.js` in a non-type-module package) Node's loader picks the
 * right format automatically and `require()` just works. For `.js` in a
-* `"type": "module"` package, Node infers ESM from package.json and the file
-* fails with `require is not defined`. In that case we copy the source to a
-* sibling temp `.cjs` (where the explicit extension forces CJS regardless of
-* the parent type field) and require *that*. Relative imports inside the
-* config still resolve against the original directory.
+* `"type": "module"` package, retry through the shared in-memory CommonJS
+* loader so nested local `.js` dependencies retain CommonJS semantics too.
 */
 async function loadConfigViaRequire(configPath, root, phase) {
 	const require = createRequire(path.join(root, "package.json"));
 	try {
 		return await unwrapConfig(require(configPath), phase);
 	} catch (e) {
-		if (!isCjsError(e) || !configPath.endsWith(".js")) throw e;
-		return await loadConfigViaCjsTempCopy(configPath, root, phase);
-	}
-}
-async function loadConfigViaCjsTempCopy(configPath, root, phase) {
-	const dir = path.dirname(configPath);
-	const tmpPath = path.join(dir, `.vinext-next-config.${process.pid}.${Date.now()}.cjs`);
-	fs.copyFileSync(configPath, tmpPath);
-	try {
-		return await unwrapConfig(createRequire(path.join(root, "package.json"))(tmpPath), phase);
-	} finally {
-		try {
-			fs.unlinkSync(tmpPath);
-		} catch {}
+		if (!shouldRetryAsCommonJs(e, configPath)) throw e;
+		return await unwrapConfig(loadCommonJsModule(configPath), phase);
 	}
 }
 /**
@@ -454,6 +440,58 @@ function readStringArray(value) {
 	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
 /**
+* Convert lightningcss feature names from `experimental.lightningCssFeatures`
+* into a numeric bitmask consumable by the `lightningcss` `transform()` /
+* `bundle()` API (the `include` / `exclude` options).
+*
+* The mapping mirrors Next.js exactly so the same dash-case feature names
+* accepted by `next.config` produce the same bits on both sides. See:
+*  - `.nextjs-ref/packages/next/src/server/config-shared.ts` (`LIGHTNINGCSS_FEATURE_NAMES`)
+*  - `.nextjs-ref/crates/next-core/src/next_config.rs` (`lightningcss_feature_names_to_mask`)
+*  - `lightningcss/node/targets.d.ts` (`Features` enum bits)
+*
+* Unknown names emit a warning (matching the Next.js Rust path, which errors;
+* we warn instead so a stray name doesn't break the whole build).
+*/
+const LIGHTNINGCSS_FEATURE_BITS = {
+	nesting: 1,
+	"not-selector-list": 2,
+	"dir-selector": 4,
+	"lang-selector-list": 8,
+	"is-selector": 16,
+	"text-decoration-thickness-percent": 32,
+	"media-interval-syntax": 64,
+	"media-range-syntax": 128,
+	"custom-media-queries": 256,
+	"clamp-function": 512,
+	"color-function": 1024,
+	"oklab-colors": 2048,
+	"lab-colors": 4096,
+	"p3-colors": 8192,
+	"hex-alpha-colors": 16384,
+	"space-separated-color-notation": 32768,
+	"font-family-system-ui": 65536,
+	"double-position-gradients": 131072,
+	"vendor-prefixes": 262144,
+	"logical-properties": 524288,
+	"light-dark": 1048576,
+	selectors: 31,
+	"media-queries": 448,
+	colors: 1113088
+};
+function lightningCssFeatureNamesToMask(names) {
+	let mask = 0;
+	for (const name of names) {
+		const bit = LIGHTNINGCSS_FEATURE_BITS[name];
+		if (bit === void 0) {
+			console.warn(`[vinext] Unknown lightningcss feature name "${name}" in experimental.lightningCssFeatures — ignoring.`);
+			continue;
+		}
+		mask |= bit;
+	}
+	return mask;
+}
+/**
 * Serialize a `compiler.define` / `compiler.defineServer` map into the
 * Vite-friendly `Record<string, string>` shape where each value is already
 * a JSON-encoded literal of source code. Entries whose values are not a
@@ -500,7 +538,7 @@ function resolveStaleTimes(experimental) {
 * Resolve a NextConfig into a fully-resolved ResolvedNextConfig.
 * Awaits async functions for redirects/rewrites/headers.
 */
-async function resolveNextConfig(config, root = process.cwd()) {
+async function resolveNextConfig(config, root = process.cwd(), options = {}) {
 	if (!config) {
 		const buildId = await resolveBuildId(void 0);
 		const deploymentId = resolveDeploymentId(void 0);
@@ -511,7 +549,10 @@ async function resolveNextConfig(config, root = process.cwd()) {
 			trailingSlash: false,
 			output: "",
 			pageExtensions: normalizePageExtensions(),
+			resolveExtensions: null,
+			serverResolveExtensions: null,
 			cacheComponents: false,
+			appNavFailHandling: false,
 			gestureTransition: false,
 			prefetchInlining: false,
 			redirects: [],
@@ -545,11 +586,17 @@ async function resolveNextConfig(config, root = process.cwd()) {
 			sassOptions: null,
 			removeConsole: false,
 			disableOptimizedLoading: false,
+			scrollRestoration: false,
 			compilerDefine: {},
 			compilerDefineServer: {},
 			instrumentationClientInject: [],
 			clientTraceMetadata: void 0,
-			staleTimes: { ...DEFAULT_STALE_TIMES }
+			staleTimes: { ...DEFAULT_STALE_TIMES },
+			useLightningcss: false,
+			lightningCssFeatures: {
+				include: 0,
+				exclude: 0
+			}
 		};
 		detectNextIntlConfig(root, resolved);
 		return resolved;
@@ -587,7 +634,7 @@ async function resolveNextConfig(config, root = process.cwd()) {
 	}
 	let headers = [];
 	if (config.headers) headers = await config.headers();
-	const webpackProbe = await probeWebpackConfig(config, root);
+	const webpackProbe = await probeWebpackConfig(config, root, options.dev ?? false);
 	const mdx = webpackProbe.mdx;
 	const aliases = {
 		...extractTurboAliases(config, root),
@@ -621,12 +668,22 @@ async function resolveNextConfig(config, root = process.cwd()) {
 	const serverExternalPackages = topLevelServerExternalPackages ?? legacyServerComponentsExternal;
 	if (experimental?.swcEnvOptions !== void 0) console.warn("[vinext] next.config option \"experimental.swcEnvOptions\" is not applicable and will be ignored (vinext uses Vite, not SWC). A Vite-compatible polyfill solution may be explored in the future.");
 	if (experimental?.rootParams !== void 0) console.warn("[vinext] `experimental.rootParams` is no longer needed, because `next/root-params` is available by default. You can remove it from next.config.(js|mjs|ts).");
+	const useLightningcss = experimental?.useLightningcss === true;
+	const rawLightningCssFeatures = readOptionalRecord(experimental?.lightningCssFeatures);
+	const lightningCssFeatures = {
+		include: lightningCssFeatureNamesToMask(readStringArray(rawLightningCssFeatures?.include)),
+		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 (config.webpack !== void 0) if (mdx || Object.keys(webpackProbe.aliases).length > 0) console.warn("[vinext] next.config option \"webpack\" is only partially supported. vinext preserves resolve.alias entries and MDX loader settings, but other webpack customization is ignored");
+	if (config.webpack !== void 0) if (mdx || Object.keys(webpackProbe.aliases).length > 0 || webpackProbe.resolveExtensionsCustomized) console.warn("[vinext] next.config option \"webpack\" is only partially supported. vinext preserves resolve.alias, resolve.extensions, and MDX loader settings, but other webpack customization is ignored");
 	else console.warn("[vinext] next.config option \"webpack\" is not yet supported and will be ignored");
 	const output = readOptionalString(config.output) ?? "";
 	if (output && output !== "export" && output !== "standalone") console.warn(`[vinext] Unknown output mode "${output}", ignoring`);
 	const pageExtensions = normalizePageExtensions(config.pageExtensions);
+	const experimentalTurbo = readOptionalRecord(experimental?.turbo);
+	const turbopack = readOptionalRecord(config.turbopack);
+	const resolveExtensions = Array.isArray(turbopack?.resolveExtensions) ? readStringArray(turbopack.resolveExtensions) : Array.isArray(experimentalTurbo?.resolveExtensions) ? readStringArray(experimentalTurbo.resolveExtensions) : null;
 	let i18n = null;
 	if (config.i18n) i18n = {
 		locales: config.i18n.locales,
@@ -654,8 +711,11 @@ async function resolveNextConfig(config, root = process.cwd()) {
 		trailingSlash: config.trailingSlash ?? false,
 		output: output === "export" || output === "standalone" ? output : "",
 		pageExtensions,
+		resolveExtensions: resolveExtensions ?? webpackProbe.resolveExtensions,
+		serverResolveExtensions: resolveExtensions ?? webpackProbe.serverResolveExtensions,
 		instrumentationClientInject: Array.isArray(config.instrumentationClientInject) ? config.instrumentationClientInject.filter((x) => typeof x === "string") : [],
 		cacheComponents: config.cacheComponents ?? false,
+		appNavFailHandling: experimental?.appNavFailHandling === true,
 		gestureTransition: experimental?.gestureTransition === true,
 		prefetchInlining,
 		redirects,
@@ -685,10 +745,13 @@ async function resolveNextConfig(config, root = process.cwd()) {
 		sassOptions: readOptionalRecord(config.sassOptions) ?? null,
 		removeConsole: config.compiler?.removeConsole === true ? true : isUnknownRecord(config.compiler?.removeConsole) ? { exclude: readStringArray(config.compiler.removeConsole.exclude) } : false,
 		disableOptimizedLoading: experimental?.disableOptimizedLoading === true,
+		scrollRestoration: experimental?.scrollRestoration === true,
 		compilerDefine: serializeCompilerDefine(config.compiler?.define),
 		compilerDefineServer: serializeCompilerDefine(config.compiler?.defineServer),
 		clientTraceMetadata: Array.isArray(experimental?.clientTraceMetadata) ? experimental.clientTraceMetadata.filter((value) => typeof value === "string") : void 0,
-		staleTimes: resolveStaleTimes(experimental)
+		staleTimes: resolveStaleTimes(experimental),
+		useLightningcss,
+		lightningCssFeatures
 	};
 	detectNextIntlConfig(root, resolved);
 	if (resolved.basePath !== "" && resolved.basePath !== "/" && resolved.assetPrefix === "") resolved.assetPrefix = resolved.basePath;
@@ -727,39 +790,75 @@ function extractTurboAliases(config, root) {
 		...normalizeAliasEntries(readOptionalRecord(topLevelTurbopack?.resolveAlias), root)
 	};
 }
-async function probeWebpackConfig(config, root) {
+async function probeWebpackConfig(config, root, dev) {
 	if (typeof config.webpack !== "function") return {
 		aliases: {},
-		mdx: null
-	};
-	const mockModuleRules = [];
-	const mockConfig = {
-		context: root,
-		resolve: { alias: {} },
-		module: { rules: mockModuleRules },
-		plugins: []
-	};
-	const mockOptions = {
-		defaultLoaders: { babel: { loader: "next-babel-loader" } },
-		isServer: false,
-		dev: false,
-		dir: root
+		mdx: null,
+		resolveExtensions: null,
+		serverResolveExtensions: null,
+		resolveExtensionsCustomized: false
 	};
 	try {
-		const finalConfig = await config.webpack(mockConfig, mockOptions) ?? mockConfig;
-		const rules = finalConfig.module?.rules ?? mockModuleRules;
-		invokeLoaderSideEffects(rules, root);
+		const clientProbe = await runWebpackConfigProbe(config, root, {
+			dev,
+			isServer: false
+		});
+		const serverProbe = await runWebpackConfigProbe(config, root, {
+			dev,
+			isServer: true,
+			nextRuntime: "nodejs"
+		});
+		invokeLoaderSideEffects(clientProbe.rules, root);
 		return {
-			aliases: normalizeAliasEntries(finalConfig.resolve?.alias, root),
-			mdx: extractMdxOptionsFromRules(rules)
+			aliases: normalizeAliasEntries(clientProbe.config.resolve?.alias, root),
+			mdx: extractMdxOptionsFromRules(clientProbe.rules),
+			resolveExtensions: clientProbe.resolveExtensions,
+			serverResolveExtensions: serverProbe.resolveExtensions,
+			resolveExtensionsCustomized: clientProbe.resolveExtensions !== null || serverProbe.resolveExtensions !== null
 		};
 	} catch {
 		return {
 			aliases: {},
-			mdx: null
+			mdx: null,
+			resolveExtensions: null,
+			serverResolveExtensions: null,
+			resolveExtensionsCustomized: false
 		};
 	}
 }
+const DEFAULT_WEBPACK_RESOLVE_EXTENSIONS = [
+	".js",
+	".mjs",
+	".tsx",
+	".ts",
+	".jsx",
+	".json",
+	".wasm"
+];
+async function runWebpackConfigProbe(config, root, options) {
+	const rules = [];
+	const mockConfig = {
+		context: root,
+		resolve: {
+			alias: {},
+			extensions: [...DEFAULT_WEBPACK_RESOLVE_EXTENSIONS]
+		},
+		module: { rules },
+		plugins: []
+	};
+	const finalConfig = await config.webpack(mockConfig, {
+		defaultLoaders: { babel: { loader: "next-babel-loader" } },
+		...options,
+		dir: root
+	}) ?? mockConfig;
+	const finalRules = finalConfig.module?.rules ?? rules;
+	const extensions = Array.isArray(finalConfig.resolve?.extensions) ? readStringArray(finalConfig.resolve.extensions) : null;
+	return {
+		config: finalConfig,
+		rules: finalRules,
+		resolveExtensions: extensions !== null && (extensions.length !== DEFAULT_WEBPACK_RESOLVE_EXTENSIONS.length || extensions.some((extension, index) => extension !== DEFAULT_WEBPACK_RESOLVE_EXTENSIONS[index])) ? extensions : null
+	};
+}
 /**
 * Walk webpack module rules and invoke each referenced loader once with a
 * dummy source string. Loaders that mutate `process.env` at compile time (a
@@ -839,7 +938,7 @@ function invokeLoaderSideEffects(rules, root) {
 * We probe the webpack function with a mock config to extract them.
 */
 async function extractMdxOptions(config, root = process.cwd()) {
-	return (await probeWebpackConfig(config, root)).mdx;
+	return (await probeWebpackConfig(config, root, false)).mdx;
 }
 /**
 * Probe file candidates relative to root. Returns the first one that exists,
@@ -932,4 +1031,4 @@ function extractPluginsFromOptions(opts) {
 	return null;
 }
 //#endregion
-export { PHASE_PRODUCTION_BUILD, createRscCompatibilityId, detectNextIntlConfig, extractMdxOptions, findNextConfigPath, loadNextConfig, normalizeAssetPrefix, parseBodySizeLimit, reassignsModuleExports, referencesCjsGlobals, resolveNextConfig, resolveNextConfigInput };
+export { PHASE_PRODUCTION_BUILD, createRscCompatibilityId, detectNextIntlConfig, extractMdxOptions, findNextConfigPath, lightningCssFeatureNamesToMask, loadNextConfig, normalizeAssetPrefix, parseBodySizeLimit, reassignsModuleExports, referencesCjsGlobals, resolveNextConfig, resolveNextConfigInput };

package/dist/config/tsconfig-paths.js

@@ -38,6 +38,19 @@ function resolveTsconfigPathCandidate(candidate) {
 	for (const item of candidates) if (fs.existsSync(item) && fs.statSync(item).isFile()) return item;
 	return null;
 }
+/**
+* Normalize a tsconfig `extends` field into a list of specifier strings.
+*
+* TypeScript 5.0+ allows `extends` to be either a string or an array of
+* strings. Matches Next.js's handling in
+* packages/next/src/build/next-config-ts/transpile-config.ts, where parents
+* are iterated in order and later entries override earlier ones.
+*/
+function normalizeExtends(extendsField) {
+	if (typeof extendsField === "string") return [extendsField];
+	if (Array.isArray(extendsField)) return extendsField.filter((value) => typeof value === "string");
+	return [];
+}
 function resolveTsconfigExtends(configPath, specifier) {
 	const fromDir = path.dirname(configPath);
 	if (specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("\\")) return resolveTsconfigPathCandidate(path.resolve(fromDir, specifier));
@@ -87,7 +100,7 @@ function loadResolutionFromTsconfigFile(configPath, seen) {
 	}
 	if (!parsed) return emptyResolution();
 	let resolution = emptyResolution();
-	const extendsList = typeof parsed.extends === "string" ? [parsed.extends] : [];
+	const extendsList = normalizeExtends(parsed.extends);
 	for (const extendsSpecifier of extendsList) {
 		const extendedPath = resolveTsconfigExtends(configPath, extendsSpecifier);
 		if (extendedPath) {