vinext 0.2.0 → 1.0.0-beta.0

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

@@ -6,6 +6,7 @@ type VinextLinkPrefetchRoute = {
   documentOnly?: boolean;
   isDynamic: boolean;
   patternParts: string[];
+  requiresDynamicNavigationRequest?: boolean;
 };
 /**
  * Pages Router route pattern exposed to the client so the App Router's
@@ -22,13 +23,15 @@ type VinextPagesLinkPrefetchRoute = {
   documentOnly?: boolean;
   isDynamic: boolean;
   patternParts: string[];
+  requiresDynamicNavigationRequest?: boolean;
 };
 type VinextNextData = {
   /** vinext-specific additions (not part of Next.js upstream). */__vinext?: {
     /** Absolute URL of the page module for dynamic import. */pageModuleUrl?: string; /** Absolute URL of the `_app` module for dynamic import. */
     appModuleUrl?: string; /** True when the Pages Router server has middleware/proxy configured. */
     hasMiddleware?: boolean; /** True when build-time rewrites can affect the initial Pages Router ready state. */
-    hasRewrites?: boolean;
+    hasRewrites?: boolean; /** Server-resolved Pages route URL used to hydrate fallback shells behind rewrites. */
+    routeUrl?: string;
   };
 } & NEXT_DATA;
 type BrowserVinextNextData = NonNullable<Window["__NEXT_DATA__"]> & VinextNextData;

package/dist/config/config-matchers.js

@@ -133,7 +133,7 @@ function _getRedirectIndex(redirects) {
 			const alternation = m[1];
 			const optional = m[2] === "?";
 			const suffix = "/" + m[3];
-			const altRe = safeRegExp("^(?:" + alternation + ")$");
+			const altRe = safeRegExp("^(?:" + alternation + ")$", "i");
 			if (!altRe) {
 				linear.push([i, redirect]);
 				continue;
@@ -145,9 +145,10 @@ function _getRedirectIndex(redirects) {
 				redirect,
 				originalIndex: i
 			};
-			const bucket = localeStatic.get(suffix);
+			const bucketKey = suffix.toLowerCase();
+			const bucket = localeStatic.get(bucketKey);
 			if (bucket) bucket.push(entry);
-			else localeStatic.set(suffix, [entry]);
+			else localeStatic.set(bucketKey, [entry]);
 		} else linear.push([i, redirect]);
 	}
 	index = {
@@ -393,7 +394,7 @@ function normalizeHost(hostHeader, fallbackHostname) {
 */
 function applyMiddlewareRequestHeaders(middlewareHeaders, request, options = {}) {
 	const nextHeaders = buildRequestHeadersFromMiddlewareResponse(request.headers, middlewareHeaders, options);
-	for (const key of Object.keys(middlewareHeaders)) if (key.startsWith("x-middleware-")) delete middlewareHeaders[key];
+	for (const key of Object.keys(middlewareHeaders)) if (key.startsWith("x-middleware-") && key !== "x-middleware-cache") delete middlewareHeaders[key];
 	if (nextHeaders) request = new Request(request.url, {
 		method: request.method,
 		headers: nextHeaders,
@@ -529,6 +530,12 @@ function extractConstraint(str, re) {
 function stripTrailingSlashForConfigMatch(value) {
 	return value.length > 1 && value.endsWith("/") ? value.slice(0, -1) : value;
 }
+function configPathEquals(a, b) {
+	return a.toLowerCase() === b.toLowerCase();
+}
+function configPathStartsWith(pathname, prefix) {
+	return pathname.slice(0, prefix.length).toLowerCase() === prefix.toLowerCase();
+}
 function matchConfigPattern(pathname, pattern) {
 	const pathnameHadTrailingSlash = pathname.length > 1 && pathname.endsWith("/");
 	pathname = stripTrailingSlashForConfigMatch(pathname);
@@ -558,7 +565,7 @@ function matchConfigPattern(pathname, pattern) {
 				}
 			} else if (tok[0] === ".") regexStr += "\\.";
 			else regexStr += tok[0];
-			const re = safeRegExp("^" + regexStr + "$");
+			const re = safeRegExp("^" + regexStr + "$", "i");
 			return re ? {
 				re,
 				paramNames
@@ -577,7 +584,7 @@ function matchConfigPattern(pathname, pattern) {
 		const paramName = catchAllMatch[1];
 		const isPlus = catchAllMatch[2] === "+";
 		const prefixNoSlash = prefix.replace(/\/$/, "");
-		if (!pathname.startsWith(prefixNoSlash)) return null;
+		if (!configPathStartsWith(pathname, prefixNoSlash)) return null;
 		const charAfter = pathname[prefixNoSlash.length];
 		if (charAfter !== void 0 && charAfter !== "/") return null;
 		const rest = pathname.slice(prefixNoSlash.length);
@@ -590,7 +597,7 @@ function matchConfigPattern(pathname, pattern) {
 	if (parts.length !== pathParts.length) return null;
 	const params = Object.create(null);
 	for (let i = 0; i < parts.length; i++) if (parts[i].startsWith(":")) params[parts[i].slice(1)] = pathParts[i];
-	else if (parts[i] !== pathParts[i]) return null;
+	else if (!configPathEquals(parts[i], pathParts[i])) return null;
 	return params;
 }
 /**
@@ -635,7 +642,7 @@ function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAU
 	let localeMatch = null;
 	let localeMatchIndex = Infinity;
 	if (index.localeStatic.size > 0) {
-		const noLocaleBucket = index.localeStatic.get(normalizedPathname);
+		const noLocaleBucket = index.localeStatic.get(normalizedPathname.toLowerCase());
 		if (noLocaleBucket) for (const entry of noLocaleBucket) {
 			if (!entry.optional) continue;
 			if (entry.originalIndex >= localeMatchIndex) continue;
@@ -657,7 +664,7 @@ function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAU
 		if (slashTwo !== -1) {
 			const suffix = normalizedPathname.slice(slashTwo);
 			const localePart = normalizedPathname.slice(1, slashTwo);
-			const localeBucket = index.localeStatic.get(suffix);
+			const localeBucket = index.localeStatic.get(suffix.toLowerCase());
 			if (localeBucket) for (const entry of localeBucket) {
 				if (entry.originalIndex >= localeMatchIndex) continue;
 				if (!entry.altRe.test(localePart)) continue;
@@ -748,7 +755,22 @@ function substituteDestinationParams(destination, params) {
 		paramRe = new RegExp(`:(${paramAlternation})([+*])?(?![A-Za-z0-9_])`, "g");
 		_compiledDestinationParamCache.set(cacheKey, paramRe);
 	}
-	return destination.replace(paramRe, (_token, key) => params[key]);
+	const replaceParams = (value, encodeParam) => value.replace(paramRe, (_token, key) => encodeParam(params[key]));
+	const hashIndex = destination.indexOf("#");
+	const beforeHash = hashIndex === -1 ? destination : destination.slice(0, hashIndex);
+	const hash = hashIndex === -1 ? "" : destination.slice(hashIndex);
+	const queryIndex = beforeHash.indexOf("?");
+	if (queryIndex !== -1) {
+		const beforeQuery = beforeHash.slice(0, queryIndex);
+		const query = beforeHash.slice(queryIndex + 1);
+		return `${replaceParams(beforeQuery, (value) => value)}?${replaceParams(query, encodeDestinationQueryParamValue)}${replaceParams(hash, (value) => value)}`;
+	}
+	return replaceParams(destination, (value) => value);
+}
+function encodeDestinationQueryParamValue(value) {
+	const params = new URLSearchParams();
+	params.set("", value);
+	return params.toString().slice(1);
 }
 /**
 * Substitute params into a redirect/rewrite destination and sanitize the
@@ -964,7 +986,7 @@ function matchHeaders(pathname, headers, ctx, basePathState = _BASEPATH_DEFAULT)
 	for (const rule of headers) {
 		if (!shouldEvaluateRule(rule.basePath, basePathState)) continue;
 		const source = pathnameHadTrailingSlash ? stripTrailingSlashForConfigMatch(rule.source) : rule.source;
-		const sourceRegex = getCachedRegex(_compiledHeaderSourceCache, source, () => safeRegExp("^" + escapeHeaderSource(source) + "$"));
+		const sourceRegex = getCachedRegex(_compiledHeaderSourceCache, source, () => safeRegExp("^" + escapeHeaderSource(source) + "$", "i"));
 		if (sourceRegex && sourceRegex.test(pathname)) {
 			if (rule.has || rule.missing) {
 				if (!checkHasConditions(rule.has, rule.missing, ctx)) continue;

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

@@ -82,6 +82,10 @@ type MdxOptions = {
   rehypePlugins?: unknown[];
   recmaPlugins?: unknown[];
 };
+type PrefetchInliningConfig = false | {
+  maxBundleSize: number;
+  maxSize: number;
+};
 type NextConfig = {
   /** Additional env variables */env?: Record<string, string>; /** Base URL path prefix */
   basePath?: string;
@@ -123,7 +127,15 @@ type NextConfig = {
     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 */
+  };
+  /**
+   * Enable React Strict Mode. When `true`, the client root is wrapped in
+   * `<React.StrictMode>` so React runs its dev-only strict checks (double-
+   * invoked effects/render, deprecation warnings). `null`/unset resolves per
+   * router: OFF for the Pages Router, ON for the App Router — matching Next.js.
+   * @see https://nextjs.org/docs/app/api-reference/config/next-config-js/reactStrictMode
+   */
+  reactStrictMode?: boolean | null; /** 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[]; /** Turbopack-compatible module resolution options. */
   turbopack?: {
@@ -194,6 +206,15 @@ type NextConfig = {
      * `useRouter().experimental_gesturePush()`.
      */
     gestureTransition?: boolean;
+    /**
+     * Enables App Router Segment Cache prefetch inlining. When provided as an
+     * object, thresholds are resolved with Next.js defaults and non-finite
+     * values are clamped to Number.MAX_SAFE_INTEGER.
+     */
+    prefetchInlining?: boolean | {
+      maxBundleSize?: number;
+      maxSize?: number;
+    };
     [key: string]: unknown;
   };
   /**
@@ -254,11 +275,10 @@ type ResolvedNextConfig = {
    */
   gestureTransition: boolean;
   /**
-   * Whether `experimental.prefetchInlining` is configured. Next.js uses this
-   * with the Segment Cache to fetch the route tree before the bundled inlined
-   * segment payload.
+   * Resolved `experimental.prefetchInlining` config. Next.js normalizes `true`
+   * and partial object config into concrete thresholds.
    */
-  prefetchInlining: boolean;
+  prefetchInlining: PrefetchInliningConfig;
   redirects: NextRedirect[];
   rewrites: {
     beforeFiles: NextRewrite[];
@@ -350,6 +370,16 @@ type ResolvedNextConfig = {
    * `test/e2e/optimized-loading` test fixture.
    */
   disableOptimizedLoading: boolean;
+  /**
+   * Resolved `reactStrictMode` from next.config, preserved as `boolean | null`
+   * so each router can apply its own default (Next.js resolves `null` to OFF
+   * for the Pages Router and ON for the App Router). When the effective value
+   * is `true`, the client root is wrapped in `<React.StrictMode>`.
+   *
+   * See `.nextjs-ref/packages/next/src/build/define-env.ts`
+   * (`__NEXT_STRICT_MODE` / `__NEXT_STRICT_MODE_APP`).
+   */
+  reactStrictMode: boolean | null;
   /**
    * Mirrors Next.js `experimental.scrollRestoration`. When true, the Pages
    * Router client takes ownership of browser history scroll restoration by
@@ -534,4 +564,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, lightningCssFeatureNamesToMask, loadNextConfig, normalizeAssetPrefix, parseBodySizeLimit, reassignsModuleExports, referencesCjsGlobals, resolveNextConfig, resolveNextConfigInput };
+export { HasCondition, MdxOptions, NextConfig, NextConfigInput, NextHeader, NextI18nConfig, NextRedirect, NextRewrite, PHASE_PRODUCTION_BUILD, PrefetchInliningConfig, ResolvedNextConfig, createRscCompatibilityId, detectNextIntlConfig, extractMdxOptions, findNextConfigPath, lightningCssFeatureNamesToMask, loadNextConfig, normalizeAssetPrefix, parseBodySizeLimit, reassignsModuleExports, referencesCjsGlobals, resolveNextConfig, resolveNextConfigInput };

package/dist/config/next-config.js

@@ -4,7 +4,6 @@ import { isUnknownRecord } from "../utils/record.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";
@@ -315,7 +314,7 @@ async function loadNextConfig(root, phase = DEFAULT_PHASE) {
 	const filename = path.basename(configPath);
 	const isTypeScriptConfig = /\.[cm]?ts$/.test(configPath);
 	const tsconfigResolution = loadTsconfigResolutionForRoot(root);
-	const useNativeTsconfigPaths = !!(isTypeScriptConfig ? tsconfigResolution.baseUrl : null) && getViteMajorVersion() >= 8;
+	const useNativeTsconfigPaths = !!(isTypeScriptConfig ? tsconfigResolution.baseUrl : null);
 	const normalizedConfigPath = safeRealpath(path.resolve(configPath));
 	try {
 		const { runnerImport } = await import("vite");
@@ -560,6 +559,18 @@ function resolveStaleTimes(experimental) {
 		static: Number.isFinite(staticRaw) && staticRaw >= 0 ? staticRaw : DEFAULT_STALE_TIMES.static
 	};
 }
+function normalizePrefetchInliningConfig(value) {
+	if (!value) return false;
+	const raw = isUnknownRecord(value) ? value : null;
+	const maxSize = raw ? raw.maxSize ?? 2048 : 2048;
+	const maxBundleSize = raw ? raw.maxBundleSize ?? 10240 : 10240;
+	const normalizedMaxSize = Number(maxSize);
+	const normalizedMaxBundleSize = Number(maxBundleSize);
+	return {
+		maxBundleSize: Number.isFinite(normalizedMaxBundleSize) ? normalizedMaxBundleSize : Number.MAX_SAFE_INTEGER,
+		maxSize: Number.isFinite(normalizedMaxSize) ? normalizedMaxSize : Number.MAX_SAFE_INTEGER
+	};
+}
 /**
 * Resolve a NextConfig into a fully-resolved ResolvedNextConfig.
 * Awaits async functions for redirects/rewrites/headers.
@@ -615,6 +626,7 @@ async function resolveNextConfig(config, root = process.cwd(), options = {}) {
 			sassOptions: null,
 			removeConsole: false,
 			disableOptimizedLoading: false,
+			reactStrictMode: null,
 			scrollRestoration: false,
 			compilerDefine: {},
 			compilerDefineServer: {},
@@ -683,12 +695,12 @@ async function resolveNextConfig(config, root = process.cwd(), options = {}) {
 	const optimizePackageImports = Array.isArray(rawOptimize) ? rawOptimize.filter((x) => typeof x === "string") : [];
 	const inlineCss = experimental?.inlineCss === true;
 	const globalNotFound = experimental?.globalNotFound === true;
-	const prefetchInlining = experimental?.prefetchInlining === true || isUnknownRecord(experimental?.prefetchInlining);
+	const prefetchInlining = normalizePrefetchInliningConfig(experimental?.prefetchInlining);
 	const appShells = experimental?.appShells === true;
 	if (appShells) {
 		const missingCoFlags = [];
 		if (!config.cacheComponents) missingCoFlags.push("cacheComponents");
-		if (experimental?.prefetchInlining !== true) missingCoFlags.push("experimental.prefetchInlining");
+		if (!prefetchInlining) missingCoFlags.push("experimental.prefetchInlining");
 		if (experimental?.varyParams !== true) missingCoFlags.push("experimental.varyParams");
 		if (experimental?.optimisticRouting !== true) missingCoFlags.push("experimental.optimisticRouting");
 		if (experimental?.cachedNavigations !== true) missingCoFlags.push("experimental.cachedNavigations");
@@ -791,6 +803,7 @@ async function resolveNextConfig(config, root = process.cwd(), options = {}) {
 		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,
+		reactStrictMode: typeof config.reactStrictMode === "boolean" ? config.reactStrictMode : null,
 		scrollRestoration: experimental?.scrollRestoration === true,
 		compilerDefine: serializeCompilerDefine(config.compiler?.define),
 		compilerDefineServer: serializeCompilerDefine(config.compiler?.defineServer),

package/dist/config/prerender.d.ts

@@ -1,3 +1,4 @@
+import { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, VinextCacheConfig, findVinextCacheConfigInPlugins, loadVinextCacheConfigFromViteConfig } from "../cache/cache-adapters-virtual.js";
 import { PluginOption } from "vite";
 
 //#region src/config/prerender.d.ts
@@ -18,12 +19,21 @@ type VinextPrerenderDecision = ResolvedVinextPrerenderConfig & {
   reason: VinextPrerenderDecisionReason;
 };
 declare const VINEXT_PRERENDER_CONFIG_PLUGIN_PROPERTY = "__vinextPrerenderConfig";
+declare const VINEXT_ROUTE_ROOT_CONFIG_PLUGIN_PROPERTY = "__vinextRouteRootConfig";
+type VinextRouteRootConfig = {
+  appDir?: string;
+  disableAppRouter?: boolean;
+  rscOutDir?: string;
+  ssrOutDir?: string;
+};
 type ViteConfigLoader = {
   loadConfigFromFile: typeof import("vite").loadConfigFromFile;
 };
 declare function normalizeVinextPrerenderConfig(config: VinextPrerenderConfig | undefined): ResolvedVinextPrerenderConfig | null;
 declare function findVinextPrerenderConfigInPlugins(plugins: PluginOption[] | undefined): ResolvedVinextPrerenderConfig | null;
+declare function findVinextRouteRootConfigInPlugins(plugins: PluginOption[] | undefined): VinextRouteRootConfig | null;
 declare function loadVinextPrerenderConfigFromViteConfig(vite: ViteConfigLoader, root: string): Promise<ResolvedVinextPrerenderConfig | null>;
+declare function loadVinextRouteRootConfigFromViteConfig(vite: ViteConfigLoader, root: string): Promise<VinextRouteRootConfig | null>;
 declare function resolveVinextPrerenderDecision(options: {
   prerenderAllFlag?: boolean;
   vinextPrerenderConfig?: ResolvedVinextPrerenderConfig | null;
@@ -31,4 +41,4 @@ declare function resolveVinextPrerenderDecision(options: {
 }): VinextPrerenderDecision | null;
 declare function formatVinextPrerenderLabel(decision: VinextPrerenderDecision): string;
 //#endregion
-export { ResolvedVinextPrerenderConfig, VINEXT_PRERENDER_CONFIG_PLUGIN_PROPERTY, VinextPrerenderConfig, VinextPrerenderDecision, VinextPrerenderDecisionReason, findVinextPrerenderConfigInPlugins, formatVinextPrerenderLabel, loadVinextPrerenderConfigFromViteConfig, normalizeVinextPrerenderConfig, resolveVinextPrerenderDecision };
+export { ResolvedVinextPrerenderConfig, VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, VINEXT_PRERENDER_CONFIG_PLUGIN_PROPERTY, VINEXT_ROUTE_ROOT_CONFIG_PLUGIN_PROPERTY, type VinextCacheConfig, VinextPrerenderConfig, VinextPrerenderDecision, VinextPrerenderDecisionReason, VinextRouteRootConfig, findVinextCacheConfigInPlugins, findVinextPrerenderConfigInPlugins, findVinextRouteRootConfigInPlugins, formatVinextPrerenderLabel, loadVinextCacheConfigFromViteConfig, loadVinextPrerenderConfigFromViteConfig, loadVinextRouteRootConfigFromViteConfig, normalizeVinextPrerenderConfig, resolveVinextPrerenderDecision };

package/dist/config/prerender.js

@@ -1,6 +1,8 @@
 import { isUnknownRecord } from "../utils/record.js";
+import { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, findVinextCacheConfigInPlugins, loadVinextCacheConfigFromViteConfig } from "../cache/cache-adapters-virtual.js";
 //#region src/config/prerender.ts
 const VINEXT_PRERENDER_CONFIG_PLUGIN_PROPERTY = "__vinextPrerenderConfig";
+const VINEXT_ROUTE_ROOT_CONFIG_PLUGIN_PROPERTY = "__vinextRouteRootConfig";
 function normalizeVinextPrerenderConfig(config) {
 	if (config === void 0) return null;
 	if (config === true) return { routes: "*" };
@@ -25,12 +27,28 @@ function findVinextPrerenderConfigInPlugins(plugins) {
 	}
 	return null;
 }
+function findVinextRouteRootConfigInPlugins(plugins) {
+	const flattened = [];
+	flattenPluginOptions(plugins, flattened);
+	for (const plugin of flattened) {
+		if (!isUnknownRecord(plugin)) continue;
+		const routeRootConfig = plugin[VINEXT_ROUTE_ROOT_CONFIG_PLUGIN_PROPERTY];
+		if (routeRootConfig) return routeRootConfig;
+	}
+	return null;
+}
 async function loadVinextPrerenderConfigFromViteConfig(vite, root) {
 	return findVinextPrerenderConfigInPlugins((await vite.loadConfigFromFile({
 		command: "build",
 		mode: "production"
 	}, void 0, root))?.config.plugins);
 }
+async function loadVinextRouteRootConfigFromViteConfig(vite, root) {
+	return findVinextRouteRootConfigInPlugins((await vite.loadConfigFromFile({
+		command: "build",
+		mode: "production"
+	}, void 0, root))?.config.plugins);
+}
 function resolveVinextPrerenderDecision(options) {
 	if (options.prerenderAllFlag) return {
 		routes: "*",
@@ -52,4 +70,4 @@ function formatVinextPrerenderLabel(decision) {
 	return "Pre-rendering all routes...";
 }
 //#endregion
-export { VINEXT_PRERENDER_CONFIG_PLUGIN_PROPERTY, findVinextPrerenderConfigInPlugins, formatVinextPrerenderLabel, loadVinextPrerenderConfigFromViteConfig, normalizeVinextPrerenderConfig, resolveVinextPrerenderDecision };
+export { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, VINEXT_PRERENDER_CONFIG_PLUGIN_PROPERTY, VINEXT_ROUTE_ROOT_CONFIG_PLUGIN_PROPERTY, findVinextCacheConfigInPlugins, findVinextPrerenderConfigInPlugins, findVinextRouteRootConfigInPlugins, formatVinextPrerenderLabel, loadVinextCacheConfigFromViteConfig, loadVinextPrerenderConfigFromViteConfig, loadVinextRouteRootConfigFromViteConfig, normalizeVinextPrerenderConfig, resolveVinextPrerenderDecision };

package/dist/config/tsconfig-paths.js

@@ -143,7 +143,11 @@ function loadTsconfigResolutionForRoot(projectRoot) {
 	for (const name of TSCONFIG_FILES) {
 		const candidate = path.join(projectRoot, name);
 		if (!fs.existsSync(candidate)) continue;
-		return loadResolutionFromTsconfigFile(candidate, /* @__PURE__ */ new Set());
+		const resolution = loadResolutionFromTsconfigFile(candidate, /* @__PURE__ */ new Set());
+		return {
+			aliases: Object.fromEntries(Object.entries(resolution.aliases).sort((a, b) => b[0].length - a[0].length)),
+			baseUrl: resolution.baseUrl
+		};
 	}
 	return emptyResolution();
 }

package/dist/entries/app-browser-entry.js

@@ -47,12 +47,16 @@ function toDocumentOnlyAppRoute(route) {
 		isDynamic: route.isDynamic
 	};
 }
+function requiresDynamicNavigationRequest(route) {
+	return route.isDynamic && route.parallelSlots.length > 0;
+}
 /** Project an `AppRoute` down to the public `VinextLinkPrefetchRoute` shape. */
 function toLinkPrefetchRoute(route) {
 	return {
 		canPrefetchLoadingShell: route.loadingPath !== null,
 		patternParts: [...route.patternParts],
-		isDynamic: route.isDynamic
+		isDynamic: route.isDynamic,
+		...requiresDynamicNavigationRequest(route) ? { requiresDynamicNavigationRequest: true } : {}
 	};
 }
 function buildRouteManifestExpression(routeManifest) {

package/dist/entries/app-rsc-entry.d.ts

@@ -1,4 +1,4 @@
-import { NextHeader, NextI18nConfig, NextRedirect, NextRewrite } from "../config/next-config.js";
+import { NextHeader, NextI18nConfig, NextRedirect, NextRewrite, PrefetchInliningConfig } from "../config/next-config.js";
 import { AppRoute } from "../routing/app-route-graph.js";
 import { MetadataFileRoute } from "../server/metadata-routes.js";
 import { ImageConfig } from "../server/image-optimization.js";
@@ -45,7 +45,8 @@ type AppRouterConfig = {
   cacheMaxMemorySize?: number; /** Inline app CSS into production HTML (from experimental.inlineCss). */
   inlineCss?: boolean; /** Enable standalone route-miss 404 handling (from experimental.globalNotFound). */
   globalNotFound?: boolean; /** Enables Next.js Cache Components semantics for App Router document HTML. */
-  cacheComponents?: boolean; /** Whether the RSC build discovered any server references. Defaults to true. */
+  cacheComponents?: boolean; /** Resolved `experimental.prefetchInlining` thresholds. */
+  prefetchInlining?: PrefetchInliningConfig; /** Whether the RSC build discovered any server references. Defaults to true. */
   hasServerActions?: boolean; /** Internationalization routing config for middleware matcher locale handling. */
   i18n?: NextI18nConfig | null;
   imageConfig?: ImageConfig;

package/dist/entries/app-rsc-entry.js

@@ -78,6 +78,7 @@ function generateRscEntry(appDir, routes, middlewarePath, metadataRoutes, global
 	const cacheMaxMemorySize = config?.cacheMaxMemorySize;
 	const inlineCss = config?.inlineCss === true;
 	const cacheComponents = config?.cacheComponents === true;
+	const prefetchInlining = config?.prefetchInlining ?? false;
 	const hasServerActions = config?.hasServerActions !== false;
 	const i18nConfig = config?.i18n ?? null;
 	const hasPagesDir = config?.hasPagesDir ?? false;
@@ -493,6 +494,7 @@ export default createAppRscHandler({
   basePath: __basePath,
   buildId: process.env.__VINEXT_BUILD_ID ?? null,
   ensureRouteLoaded: __ensureRouteLoaded,
+  prefetchInlining: ${JSON.stringify(prefetchInlining)},
   clearRequestContext() {
     __clearRequestContext();
   },
@@ -527,6 +529,7 @@ export default createAppRscHandler({
     staticParamsValidationParams,
     rootParams,
     request,
+    renderedPathAndSearch,
     route,
     scriptNonce,
     searchParams,
@@ -693,6 +696,7 @@ export default createAppRscHandler({
       prerenderToReadableStream,
       request,
       revalidateSeconds: __segmentConfig.revalidateSeconds,
+      renderedPathAndSearch,
       resolveRouteFetchCacheMode(targetRoute) {
         return __resolveRouteFetchCacheMode(targetRoute);
       },

package/dist/entries/pages-client-entry.js

@@ -57,7 +57,10 @@ async function generateClientEntry(pagesDir, nextConfig, fileMatcher, options =
 		return `  ${JSON.stringify(nextFormatPattern)}: () => import(${JSON.stringify(absPath)})`;
 	});
 	const appFileBase = appFilePath ? normalizePathSeparators(appFilePath) : void 0;
-	return `${instrumentationClientPath ? `import ${JSON.stringify(normalizePathSeparators(instrumentationClientPath))};\n` : ""}${options.reactPreamble === false ? "" : "import \"@vitejs/plugin-react/preamble\";\n"}
+	const userInstrumentationImport = instrumentationClientPath ? `import ${JSON.stringify(normalizePathSeparators(instrumentationClientPath))};\n` : "";
+	const reactPreambleImport = options.reactPreamble === false ? "" : "import \"@vitejs/plugin-react/preamble\";\n";
+	const reactStrictModeEnabled = nextConfig.reactStrictMode === true;
+	return `${userInstrumentationImport}${reactPreambleImport}
 import "vinext/instrumentation-client";
 import React from "react";
 import { hydrateRoot } from "react-dom/client";
@@ -89,6 +92,9 @@ const appLoader = undefined;
 // can iterate in order and trust the first match.
 window.__VINEXT_PAGE_LOADERS__ = pageLoaders;
 window.__VINEXT_PAGE_PATTERNS__ = Object.keys(pageLoaders);
+// reactStrictMode flag — read by wrapWithRouterContext (next/router) so the
+// <React.StrictMode> wrap is applied on initial hydration and every navigation.
+window.__VINEXT_REACT_STRICT_MODE__ = ${JSON.stringify(reactStrictModeEnabled)};
 window.__VINEXT_PAGES_SSG_PATTERNS__ = ${JSON.stringify(pagesSsgPatterns)};
 window.__VINEXT_PAGES_SSP_PATTERNS__ = ${JSON.stringify(pagesSspPatterns)};
 window.__VINEXT_MIDDLEWARE_MATCHER__ = ${JSON.stringify(options.middlewareMatcher)};
@@ -186,6 +192,9 @@ async function hydrate() {
   });
 
   // Wrap with RouterContext.Provider so next/router and next/compat/router work during hydration.
+  // When reactStrictMode is enabled, wrapWithRouterContext also wraps the tree
+  // in <React.StrictMode> (see next/router) — applied here and on every
+  // navigation render, matching Next.js.
   element = wrapWithRouterContext(element, resolveHydrationCommit);
 
   const container = document.getElementById("__next");
@@ -204,9 +213,11 @@ async function hydrate() {
   window.__NEXT_HYDRATED_CB?.();
 
   if (nextData.isFallback) {
+    const currentUrl = window.location.pathname + window.location.search + window.location.hash;
+    const routeUrl = nextData.__vinext?.routeUrl;
     await Router.replace(
-      window.location.pathname + window.location.search + window.location.hash,
-      undefined,
+      routeUrl || currentUrl,
+      routeUrl ? currentUrl : undefined,
       { _h: 1, scroll: false },
     );
   }

package/dist/entries/pages-server-entry.js

@@ -4,6 +4,8 @@ import { apiRouter, pagesRouter } from "../routing/pages-router.js";
 import { resolveEntryPath } from "./runtime-entry-module.js";
 import { isProxyFile } from "../server/middleware.js";
 import "./pages-entry-helpers.js";
+import { hasExportedName } from "../build/report.js";
+import { readFile } from "node:fs/promises";
 //#region src/entries/pages-server-entry.ts
 /**
 * Pages Router server entry generator.
@@ -24,6 +26,12 @@ const _pagesApiRoutePath = resolveEntryPath("../server/pages-api-route.js", impo
 const _serverGlobalsPath = resolveEntryPath("../server/server-globals.js", import.meta.url);
 const _queryUtilsPath = resolveEntryPath("../utils/query.js", import.meta.url);
 const _pagesPageHandlerPath = resolveEntryPath("../server/pages-page-handler.js", import.meta.url);
+async function getPagesDataKind(filePath) {
+	const source = await readFile(filePath, "utf8");
+	if (hasExportedName(source, "getStaticProps")) return "static";
+	if (hasExportedName(source, "getServerSideProps")) return "server";
+	return "none";
+}
 /**
 * Generate the virtual SSR server entry module.
 * This is the entry point for `vite build --ssr`.
@@ -39,10 +47,11 @@ async function generateServerEntry(pagesDir, nextConfig, fileMatcher, middleware
 		const absPath = normalizePathSeparators(r.filePath);
 		return `import * as api_${i} from ${JSON.stringify(absPath)};`;
 	});
-	const pageRouteEntries = pageRoutes.map((r, i) => {
+	const pageRouteEntries = await Promise.all(pageRoutes.map(async (r, i) => {
 		const absPath = normalizePathSeparators(r.filePath);
-		return `  { pattern: ${JSON.stringify(r.pattern)}, patternParts: ${JSON.stringify(r.patternParts)}, isDynamic: ${r.isDynamic}, params: ${JSON.stringify(r.params)}, module: page_${i}, filePath: ${JSON.stringify(absPath)} }`;
-	});
+		const dataKind = await getPagesDataKind(r.filePath);
+		return `  { pattern: ${JSON.stringify(r.pattern)}, patternParts: ${JSON.stringify(r.patternParts)}, isDynamic: ${r.isDynamic}, params: ${JSON.stringify(r.params)}, module: page_${i}, filePath: ${JSON.stringify(absPath)}, dataKind: ${JSON.stringify(dataKind)} }`;
+	}));
 	const apiRouteEntries = apiRoutes.map((r, i) => `  { pattern: ${JSON.stringify(r.pattern)}, patternParts: ${JSON.stringify(r.patternParts)}, isDynamic: ${r.isDynamic}, params: ${JSON.stringify(r.params)}, module: api_${i} }`);
 	const appFilePath = findFileWithExts(pagesDir, "_app", fileMatcher);
 	const docFilePath = findFileWithExts(pagesDir, "_document", fileMatcher);
@@ -164,7 +173,12 @@ const i18nConfig = ${i18nConfigJson};
 // to load next.config.js at runtime.
 export const buildId = ${buildIdJson};
 export function normalizeDataRequest(request) {
-  return __normalizePagesDataRequest(request, buildId);
+  return __normalizePagesDataRequest(
+    request,
+    buildId,
+    vinextConfig.basePath,
+    hasMiddleware && vinextConfig.trailingSlash,
+  );
 }
 export const hasMiddleware = ${JSON.stringify(Boolean(middlewarePath))};
 

package/dist/image/image-adapters-virtual.js

@@ -44,6 +44,7 @@ function generateImageAdaptersModule(images) {
 		"let __vinextImageOptimizerRegistered = false;",
 		"",
 		"export function registerConfiguredImageOptimizer(env) {",
+		"  if (typeof process !== 'undefined' && process.env?.__VINEXT_PRERENDER_PATH_DISCOVERY === '1') return;",
 		"  if (__vinextImageOptimizerRegistered) return;",
 		"  __vinextImageOptimizerRegistered = true;",
 		"  try {",

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 import { NextConfig, NextConfigInput } from "./config/next-config.js";
-import { AppStaticExportOptions, StaticExportOptions, StaticExportResult, staticExportApp, staticExportPages } from "./build/static-export.js";
 import { VinextCacheConfig } from "./cache/cache-adapters-virtual.js";
 import { VinextPrerenderConfig } from "./config/prerender.js";
+import { AppStaticExportOptions, StaticExportOptions, StaticExportResult, staticExportApp, staticExportPages } from "./build/static-export.js";
 import { VinextImageConfig } from "./image/image-adapters-virtual.js";
 import { PluginOption } from "vite";
 import { Options } from "@vitejs/plugin-react";