vinext 0.1.1 → 0.1.3

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,26 +344,30 @@ 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.
+*
+* `cookies` and `query` are lazy memoized getters: they are consumed only by
+* `has`/`missing` condition evaluation (`checkHasConditions` /
+* `matchesRuleConditions`), and most apps configure no such conditions. The
+* cookie split and `searchParams` access are therefore deferred until first
+* read and computed at most once. Mirrors `headersContextFromRequest` in
+* `shims/headers.ts`.
 */
 function requestContextFromRequest(request) {
 	const url = new URL(request.url);
+	let cookies;
+	let query;
 	return {
 		headers: request.headers,
-		cookies: parseCookies(request.headers.get("cookie")),
-		query: url.searchParams,
+		get cookies() {
+			return cookies ??= parseCookies(request.headers.get("cookie"));
+		},
+		get query() {
+			return query ??= url.searchParams;
+		},
 		host: normalizeHost(request.headers.get("host"), url.hostname)
 	};
 }
@@ -429,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": {
@@ -528,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 = "";
@@ -703,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;
@@ -740,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}`.
@@ -181,6 +187,15 @@ 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()`.
+     */
+    gestureTransition?: boolean;
+    [key: string]: unknown;
+  };
   /**
    * Path to a custom cache handler module (e.g., KV, Redis, DynamoDB).
    * Accepts relative paths, absolute paths, or file:// URLs from import.meta.resolve().
@@ -228,8 +243,16 @@ 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()`.
+   */
+  gestureTransition: boolean;
   /**
    * Whether `experimental.prefetchInlining` is configured. Next.js uses this
    * with the Segment Cache to fetch the route tree before the bundled inlined
@@ -324,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
@@ -365,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
@@ -444,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.
@@ -476,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,11 @@ 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: [],
 			rewrites: {
@@ -544,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;
@@ -586,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),
@@ -620,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,
@@ -653,8 +711,12 @@ 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,
 		rewrites,
@@ -683,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;
@@ -725,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
@@ -837,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,
@@ -930,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/deploy.d.ts

@@ -1,4 +1,5 @@
 import { ensureESModule as ensureESModule$1, renameCJSConfigs as renameCJSConfigs$1 } from "./utils/project.js";
+import { execFileSync } from "node:child_process";
 
 //#region src/deploy.d.ts
 type DeployOptions = {
@@ -151,21 +152,39 @@ type WranglerDeployArgs = {
   args: string[];
   env: string | undefined;
 };
+declare function validateWranglerEnvName(env: string): string;
 declare function buildWranglerDeployArgs(options: Pick<DeployOptions, "preview" | "env">): WranglerDeployArgs;
 /**
- * Resolve the wrangler executable in node_modules.
+ * Resolve Wrangler's JavaScript CLI entrypoint in node_modules.
  *
- * Walks up ancestor directories so the binary is found even when node_modules
- * is hoisted to the workspace root in a monorepo.
+ * Invoking the JavaScript file through `process.execPath` avoids the `.cmd`
+ * shim and command shell that package managers create on Windows.
+ */
+declare function resolveWranglerBin(root: string, resolvePackageJson?: (root: string) => string | null): string;
+declare function buildNodeCliInvocation(scriptPath: string, args: string[], nodeExecutable?: string): {
+  file: string;
+  args: string[];
+};
+declare function buildWranglerInvocation(root: string, options: Pick<DeployOptions, "preview" | "env">, nodeExecutable?: string): {
+  file: string;
+  args: string[];
+  env: string | undefined;
+};
+declare function runWranglerDeploy(root: string, options: Pick<DeployOptions, "preview" | "env">, execute?: typeof execFileSync): string;
+/**
+ * Read the prerender manifest and inject pregenerated concrete paths into the
+ * App Router Worker bundle so the PPR fallback-shell guard is populated at
+ * module init time without calling `seedMemoryCacheFromPrerender`.
+ *
+ * The paths are injected as `globalThis.__VINEXT_PREGENERATED_CONCRETE_PATHS`
+ * wrapped in replaceable marker comments, and consumed by
+ * `initPregeneratedPathsFromGlobals` in the generated RSC entry.
  *
- * On Windows, `node_modules/.bin/` contains both a Unix shebang script (no
- * extension) and a `.CMD` shim. Node's `execFileSync` uses CreateProcess(),
- * which only resolves PATHEXT extensions (`.cmd`, `.exe`, ...) — spawning the
- * bare-name shebang file fails with ENOENT even though the file exists. So on
- * Windows we prefer the `.CMD` shim and only fall back to the bare name for a
- * clearer error message if neither is present.
+ * Idempotent: repeated calls strip the previous injection before writing the
+ * new one. If the manifest is missing, corrupt, or empty, any prior injection
+ * is stripped and nothing new is written — failing closed to empty.
  */
-declare function resolveWranglerBin(root: string, platform?: NodeJS.Platform): string;
+declare function injectPregeneratedConcretePaths(root: string): void;
 declare function deploy(options: DeployOptions): Promise<void>;
 //#endregion
-export { buildWranglerDeployArgs, deploy, detectProject, ensureESModule, formatMissingCacheAdapterError, formatMissingCloudflarePluginError, generateAppRouterViteConfig, generateAppRouterWorkerEntry, generatePagesRouterViteConfig, generatePagesRouterWorkerEntry, generateWranglerConfig, getFilesToGenerate, getMissingDeps, hasWranglerConfig, isPackageResolvable, parseDeployArgs, renameCJSConfigs, resolveWranglerBin, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, withCloudflareEnv, workerEntryHasCacheHandler };
+export { buildNodeCliInvocation, buildWranglerDeployArgs, buildWranglerInvocation, deploy, detectProject, ensureESModule, formatMissingCacheAdapterError, formatMissingCloudflarePluginError, generateAppRouterViteConfig, generateAppRouterWorkerEntry, generatePagesRouterViteConfig, generatePagesRouterWorkerEntry, generateWranglerConfig, getFilesToGenerate, getMissingDeps, hasWranglerConfig, injectPregeneratedConcretePaths, isPackageResolvable, parseDeployArgs, renameCJSConfigs, resolveWranglerBin, runWranglerDeploy, validateWranglerEnvName, viteConfigHasCacheAdapter, viteConfigHasCloudflarePlugin, withCloudflareEnv, workerEntryHasCacheHandler };