vinext 1.0.0-beta.8 → 1.0.0

package/dist/config/config-matchers.js

@@ -1,7 +1,7 @@
-import { normalizeHost, parseCookies, requestContextFromRequest } from "./request-context.js";
 import { PRERENDER_REVALIDATE_HEADER, PRERENDER_REVALIDATE_ONLY_GENERATED_HEADER, VINEXT_MW_CTX_HEADER, VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
 import { buildRequestHeadersFromMiddlewareResponse, getUnconsumedMiddlewareRequestHeaders } from "../utils/middleware-request-headers.js";
 import { analyzeRegexSafety } from "../utils/regex-safety.js";
+import { normalizeHost, parseCookies, requestContextFromRequest } from "./request-context.js";
 import { isExternalUrl } from "../utils/external-url.js";
 //#region src/config/config-matchers.ts
 /**
@@ -258,9 +258,7 @@ function escapeHeaderSource(source) {
 		case "*":
 			result += ".*";
 			break;
-		default:
-			result += m[0];
-			break;
+		default: result += m[0];
 	}
 	return result;
 }
@@ -546,7 +544,7 @@ function matchConfigPattern(pathname, pattern) {
 * an original index < N are checked via matchConfigPattern first — they are
 * few in practice (typically zero) so this is not a hot-path concern.
 */
-function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAULT) {
+function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAULT, onRuleSourceMatch) {
 	if (redirects.length === 0) return null;
 	const normalizedPathname = stripTrailingSlashForConfigMatch(pathname);
 	const index = _getRedirectIndex(redirects);
@@ -559,6 +557,7 @@ function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAU
 			if (entry.originalIndex >= localeMatchIndex) continue;
 			const redirect = entry.redirect;
 			if (!shouldEvaluateRule(redirect.basePath, basePathState)) continue;
+			onRuleSourceMatch?.(redirect);
 			const conditionParams = redirect.has || redirect.missing ? collectConditionParams(redirect.has, redirect.missing, ctx) : _emptyParams();
 			if (!conditionParams) continue;
 			localeMatch = {
@@ -581,6 +580,7 @@ function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAU
 				if (!entry.altRe.test(localePart)) continue;
 				const redirect = entry.redirect;
 				if (!shouldEvaluateRule(redirect.basePath, basePathState)) continue;
+				onRuleSourceMatch?.(redirect);
 				const conditionParams = redirect.has || redirect.missing ? collectConditionParams(redirect.has, redirect.missing, ctx) : _emptyParams();
 				if (!conditionParams) continue;
 				localeMatch = {
@@ -600,6 +600,7 @@ function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAU
 		if (!shouldEvaluateRule(redirect.basePath, basePathState)) continue;
 		const params = matchConfigPattern(pathname, redirect.source);
 		if (params) {
+			onRuleSourceMatch?.(redirect);
 			const conditionParams = redirect.has || redirect.missing ? collectConditionParams(redirect.has, redirect.missing, ctx) : _emptyParams();
 			if (!conditionParams) continue;
 			return {
@@ -621,11 +622,12 @@ function matchRedirect(pathname, redirects, ctx, basePathState = _BASEPATH_DEFAU
 * to evaluate has/missing conditions. Next.js always has request context
 * when evaluating rewrites, so this parameter is required.
 */
-function matchRewrite(pathname, rewrites, ctx, basePathState = _BASEPATH_DEFAULT, paramsPathname = pathname) {
+function matchRewrite(pathname, rewrites, ctx, basePathState = _BASEPATH_DEFAULT, paramsPathname = pathname, onRuleSourceMatch) {
 	for (const rewrite of rewrites) {
 		if (!shouldEvaluateRule(rewrite.basePath, basePathState)) continue;
 		const matchedParams = matchConfigPattern(pathname, rewrite.source);
 		if (matchedParams) {
+			onRuleSourceMatch?.(rewrite);
 			const params = paramsPathname === pathname ? matchedParams : matchConfigPattern(paramsPathname, rewrite.source) ?? matchedParams;
 			const conditionParams = rewrite.has || rewrite.missing ? collectConditionParams(rewrite.has, rewrite.missing, ctx) : _emptyParams();
 			if (!conditionParams) continue;
@@ -891,7 +893,7 @@ async function proxyExternalRequest(request, externalUrl) {
 * to evaluate has/missing conditions. Next.js always has request context
 * when evaluating headers, so this parameter is required.
 */
-function matchHeaders(pathname, headers, ctx, basePathState = _BASEPATH_DEFAULT) {
+function matchHeaders(pathname, headers, ctx, basePathState = _BASEPATH_DEFAULT, onRuleSourceMatch) {
 	const pathnameHadTrailingSlash = pathname.length > 1 && pathname.endsWith("/");
 	pathname = stripTrailingSlashForConfigMatch(pathname);
 	const result = [];
@@ -900,6 +902,7 @@ function matchHeaders(pathname, headers, ctx, basePathState = _BASEPATH_DEFAULT)
 		const source = pathnameHadTrailingSlash ? stripTrailingSlashForConfigMatch(rule.source) : rule.source;
 		const sourceRegex = getCachedRegex(_compiledHeaderSourceCache, source, () => safeRegExp("^" + escapeHeaderSource(source) + "$", "i"));
 		if (sourceRegex && sourceRegex.test(pathname)) {
+			onRuleSourceMatch?.(rule);
 			if (rule.has || rule.missing) {
 				if (!checkHasConditions(rule.has, rule.missing, ctx)) continue;
 			}

package/dist/config/dotenv.d.ts

@@ -22,7 +22,7 @@ type LoadDotenvResult = {
 /**
  * Next.js-compatible dotenv lookup order (highest priority first).
  */
-declare function getDotenvFiles(mode: string): string[];
+export declare function getDotenvFiles(mode: string): string[];
 /**
  * Load .env files into processEnv with Next.js-like precedence:
  * process.env > .env.<mode>.local > .env.local > .env.<mode> > .env.
@@ -46,6 +46,5 @@ declare function getDotenvFiles(mode: string): string[];
  * pass is effectively a no-op for overlapping keys. For `start` and `deploy`
  * commands (which don't go through Vite at all), this is the only loading.
  */
-declare function loadDotenv({ root, mode, processEnv }: LoadDotenvOptions): LoadDotenvResult;
-//#endregion
-export { getDotenvFiles, loadDotenv };
+export declare function loadDotenv({ root, mode, processEnv }: LoadDotenvOptions): LoadDotenvResult;
+//#endregion

package/dist/config/dotenv.js

@@ -42,7 +42,8 @@ function loadDotenv({ root, mode, processEnv = process.env }) {
 	for (const relativeFile of getDotenvFiles(mode)) {
 		const filePath = path.join(root, relativeFile);
 		if (!fs.existsSync(filePath)) continue;
-		const expanded = expandEnv(parseEnv(fs.readFileSync(filePath, "utf-8")), processEnv);
+		const fileContent = fs.readFileSync(filePath, "utf-8");
+		const expanded = expandEnv(parseEnv(fileContent), processEnv);
 		for (const [key, value] of Object.entries(expanded)) {
 			if (processEnv[key] !== void 0) continue;
 			processEnv[key] = value;

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

@@ -1,7 +1,7 @@
 import { PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
 import { PluginOption } from "vite";
 //#region src/config/next-config.d.ts
-declare const VINEXT_NEXT_CONFIG_PLUGIN_PROPERTY = "__vinextNextConfig";
+export declare const VINEXT_NEXT_CONFIG_PLUGIN_PROPERTY = "__vinextNextConfig";
 /**
  * Parse a body size limit value (string or number) into bytes.
  * Accepts Next.js-style strings like "1mb", "500kb", "10mb", bare number strings like "1048576" (bytes),
@@ -9,13 +9,13 @@ declare const VINEXT_NEXT_CONFIG_PLUGIN_PROPERTY = "__vinextNextConfig";
  * Returns the default 1MB if the value is not provided or invalid.
  * Throws if the parsed value is less than 1.
  */
-declare function parseBodySizeLimit(value: string | number | undefined | null): number;
-type HasCondition = {
+export declare function parseBodySizeLimit(value: string | number | undefined | null): number;
+export type HasCondition = {
   type: "header" | "cookie" | "query" | "host";
   key: string;
   value?: string;
 };
-type NextRedirect = {
+export type NextRedirect = {
   source: string;
   destination: string;
   permanent: boolean;
@@ -37,7 +37,7 @@ type NextRedirect = {
    */
   basePath?: false;
 };
-type NextRewrite = {
+export type NextRewrite = {
   source: string;
   destination: string;
   has?: HasCondition[];
@@ -47,7 +47,7 @@ type NextRewrite = {
   /** See {@link NextRedirect.basePath}. */
   basePath?: false;
 };
-type NextHeader = {
+export type NextHeader = {
   source: string;
   has?: HasCondition[];
   missing?: HasCondition[];
@@ -60,7 +60,7 @@ type NextHeader = {
   /** See {@link NextRedirect.locale}. */
   locale?: false;
 };
-type NextI18nConfig = {
+export type NextI18nConfig = {
   /** List of supported locales */
   locales: string[];
   /** The default locale (used when no locale prefix is in the URL) */
@@ -85,16 +85,16 @@ type NextI18nConfig = {
  * These are passed through to @mdx-js/rollup so that custom
  * remark/rehype/recma plugins configured in next.config work with Vite.
  */
-type MdxOptions = {
+export type MdxOptions = {
   remarkPlugins?: unknown[];
   rehypePlugins?: unknown[];
   recmaPlugins?: unknown[];
 };
-type PrefetchInliningConfig = false | {
+export type PrefetchInliningConfig = false | {
   maxBundleSize: number;
   maxSize: number;
 };
-type NextConfig = {
+export type NextConfig = {
   /** Additional env variables */
   env?: Record<string, string>;
   /** Base URL path prefix */
@@ -208,7 +208,7 @@ type NextConfig = {
   cacheComponents?: boolean;
   /**
    * Enables source maps while generating static pages.
-   * Helps with errors during the prerender phase in `vinext build`.
+   * Helps with errors during the prerender phase in `vite build`.
    * Defaults to `true`. Set to `false` to disable.
    */
   enablePrerenderSourceMaps?: boolean;
@@ -289,12 +289,12 @@ type NextConfig = {
 type NextConfigFactory = (phase: string, opts: {
   defaultConfig: NextConfig;
 }) => NextConfig | Promise<NextConfig>;
-type NextConfigInput = NextConfig | NextConfigFactory;
-declare function findVinextNextConfigInPlugins(plugins: PluginOption[] | undefined): Promise<NextConfigInput | null>;
+export type NextConfigInput = NextConfig | NextConfigFactory;
+export declare function findVinextNextConfigInPlugins(plugins: PluginOption[] | undefined): Promise<NextConfigInput | null>;
 /**
  * Resolved configuration with all async values awaited.
  */
-type ResolvedNextConfig = {
+export type ResolvedNextConfig = {
   env: Record<string, string>;
   basePath: string;
   /**
@@ -321,6 +321,10 @@ type ResolvedNextConfig = {
   resolveExtensions: string[] | null;
   serverResolveExtensions: string[] | null;
   instrumentationClientInject: string[];
+  /** Route manifest injected by Next.js-compatible instrumentation plugins. */
+  instrumentationClientRouteManifest: string | undefined;
+  /** Server globals injected into instrumentation.ts by wrapped webpack configs. */
+  instrumentationServerValueInjections: Record<string, unknown>;
   cacheComponents: boolean;
   appNavFailHandling: boolean;
   /**
@@ -540,7 +544,7 @@ type ResolvedNextConfig = {
  * Note: `\bexports\b` does not match `export default` (different word
  * boundaries), and `\brequire\b` does not match `requireSomething`.
  */
-declare function referencesCjsGlobals(source: string): boolean;
+export declare function referencesCjsGlobals(source: string): boolean;
 /**
  * Static heuristic: returns true when the source appears to assign to
  * `module.exports` — either via `module.exports = …`, `module.exports.foo = …`,
@@ -558,9 +562,9 @@ declare function referencesCjsGlobals(source: string): boolean;
  * as the config — equivalent to today's sentinel logic for pure-ESM files
  * that happen to mention `module.exports` only in a string).
  */
-declare function reassignsModuleExports(source: string): boolean;
-declare function findNextConfigPath(root: string): string | null;
-declare function resolveNextConfigInput(config: NextConfigInput, phase?: string): Promise<NextConfig>;
+export declare function reassignsModuleExports(source: string): boolean;
+export declare function findNextConfigPath(root: string): string | null;
+export declare function resolveNextConfigInput(config: NextConfigInput, phase?: string): Promise<NextConfig>;
 /**
  * Find and load the next.config file from the project root.
  * Returns null if no config file is found.
@@ -572,7 +576,7 @@ declare function resolveNextConfigInput(config: NextConfigInput, phase?: string)
  * `next.config.js` files written in CJS syntax inside a `"type": "module"`
  * package (the common shape after `vinext init`).
  */
-declare function loadNextConfig(root: string, phase?: string): Promise<NextConfig | null>;
+export declare function loadNextConfig(root: string, phase?: string): Promise<NextConfig | null>;
 /**
  * Normalize the `assetPrefix` option from next.config.
  *
@@ -587,7 +591,7 @@ declare function loadNextConfig(root: string, phase?: string): Promise<NextConfi
  *
  * @see https://nextjs.org/docs/app/api-reference/config/next-config-js/assetPrefix
  */
-declare function normalizeAssetPrefix(value: unknown): string;
+export declare function normalizeAssetPrefix(value: unknown): string;
 /**
  * Resolve the App Router RSC compatibility identity for a build.
  *
@@ -598,17 +602,17 @@ declare function normalizeAssetPrefix(value: unknown): string;
  * across plugin instances); otherwise we mint a random UUID.
  *
  * NOTE: like `resolveBuildId`, this is non-deterministic in the no-deploymentId
- * case, so a single `vinext build` that instantiates the plugin more than once
+ * case, so a single `vite build` that instantiates the plugin more than once
  * (App Router `buildApp()` + the hybrid Pages Router `vite.build()`) must
  * 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;
+export declare function createRscCompatibilityId(nextConfig: Pick<ResolvedNextConfig, "deploymentId">): string;
+export 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, options?: {
+export declare function resolveNextConfig(config: NextConfig | null, root?: string, options?: {
   dev?: boolean;
 }): Promise<ResolvedNextConfig>;
 /**
@@ -619,7 +623,7 @@ declare function resolveNextConfig(config: NextConfig | null, root?: string, opt
  * loader rule. The remark/rehype plugins are captured in that closure.
  * We probe the webpack function with a mock config to extract them.
  */
-declare function extractMdxOptions(config: NextConfig, root?: string): Promise<MdxOptions | null>;
+export declare function extractMdxOptions(config: NextConfig, root?: string): Promise<MdxOptions | null>;
 /**
  * Detect next-intl in the project and auto-register the `next-intl/config`
  * alias if needed.
@@ -636,6 +640,6 @@ declare function extractMdxOptions(config: NextConfig, root?: string): Promise<M
  *
  * Mutates `resolved.aliases` and `resolved.env` in place.
  */
-declare function detectNextIntlConfig(root: string, resolved: ResolvedNextConfig): void;
+export declare function detectNextIntlConfig(root: string, resolved: ResolvedNextConfig): void;
 //#endregion
-export { HasCondition, MdxOptions, NextConfig, NextConfigInput, NextHeader, NextI18nConfig, NextRedirect, NextRewrite, PHASE_PRODUCTION_BUILD, PrefetchInliningConfig, ResolvedNextConfig, VINEXT_NEXT_CONFIG_PLUGIN_PROPERTY, createRscCompatibilityId, detectNextIntlConfig, extractMdxOptions, findNextConfigPath, findVinextNextConfigInPlugins, lightningCssFeatureNamesToMask, loadNextConfig, normalizeAssetPrefix, parseBodySizeLimit, reassignsModuleExports, referencesCjsGlobals, resolveNextConfig, resolveNextConfigInput };
+export { PHASE_PRODUCTION_BUILD };

package/dist/config/next-config.js

@@ -1,14 +1,15 @@
 import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
 import { normalizePageExtensions } from "../routing/file-matcher.js";
-import { isExternalUrl } from "../utils/external-url.js";
-import { applyLocaleToRoutes } from "./config-matchers.js";
+import { loadCommonJsModule, shouldRetryAsCommonJs } from "../utils/commonjs-loader.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 { flattenPluginOptions } from "../utils/plugin-options.js";
-import { PHASE_DEVELOPMENT_SERVER, PHASE_PRODUCTION_BUILD } from "../shims/constants.js";
+import { isExternalUrl } from "../utils/external-url.js";
+import { applyLocaleToRoutes } from "./config-matchers.js";
 import { loadTsconfigResolutionForRoot } from "./tsconfig-paths.js";
-import { loadCommonJsModule, shouldRetryAsCommonJs } from "../utils/commonjs-loader.js";
-import { createRequire } from "node:module";
+import { Module, createRequire } from "node:module";
+import { AsyncLocalStorage } from "node:async_hooks";
 import fs from "node:fs";
 import { fileURLToPath } from "node:url";
 import { randomUUID } from "node:crypto";
@@ -21,6 +22,75 @@ import commonjs from "vite-plugin-commonjs";
 * Unsupported options are logged as warnings.
 */
 const VINEXT_NEXT_CONFIG_PLUGIN_PROPERTY = "__vinextNextConfig";
+const CommonJsModule = Module;
+const vinextNextPackageJson = fileURLToPath(new URL("../../next-package.json", import.meta.url));
+let nextPackageIdentityUsers = 0;
+let originalResolveFilename;
+const processWithConfigRootState = process;
+const configRootState = processWithConfigRootState.__vinextConfigRootState ??= {
+	storage: new AsyncLocalStorage(),
+	queue: Promise.resolve()
+};
+async function withConfigRoot(root, callback) {
+	const inheritedLease = configRootState.storage.getStore();
+	const lock = inheritedLease?.active ? inheritedLease : configRootState;
+	const waitForTurn = lock.queue;
+	let release = () => {};
+	lock.queue = new Promise((resolve) => {
+		release = resolve;
+	});
+	await waitForTurn;
+	const lease = {
+		active: true,
+		queue: Promise.resolve()
+	};
+	const run = async () => {
+		const previousCwd = process.cwd();
+		process.chdir(root);
+		try {
+			return await callback();
+		} finally {
+			lease.active = false;
+			await lease.queue;
+			process.chdir(previousCwd);
+		}
+	};
+	try {
+		return await configRootState.storage.run(lease, run);
+	} finally {
+		release();
+	}
+}
+/**
+* Let Next.js config wrappers inspect the framework compatibility version even
+* after an app has replaced the `next` package with vinext.
+*
+* Existing `next` installations always win. The fallback is active only while
+* evaluating next.config, where wrappers such as next-intl and Sentry call
+* `require.resolve("next/package.json")` synchronously.
+*/
+async function withNextPackageIdentity(callback) {
+	if (nextPackageIdentityUsers++ === 0) {
+		originalResolveFilename = CommonJsModule._resolveFilename;
+		CommonJsModule._resolveFilename = function resolveFilename(request, ...args) {
+			try {
+				return originalResolveFilename.call(this, request, ...args);
+			} catch (error) {
+				if (request === "next/package.json" && error instanceof Error && "code" in error && error.code === "MODULE_NOT_FOUND") return vinextNextPackageJson;
+				throw error;
+			}
+		};
+	}
+	try {
+		return await callback();
+	} finally {
+		nextPackageIdentityUsers -= 1;
+		if (nextPackageIdentityUsers === 0 && originalResolveFilename) {
+			CommonJsModule._resolveFilename = originalResolveFilename;
+			originalResolveFilename = void 0;
+		}
+	}
+}
 /**
 * Parse a body size limit value (string or number) into bytes.
 * Accepts Next.js-style strings like "1mb", "500kb", "10mb", bare number strings like "1048576" (bytes),
@@ -29,7 +99,7 @@ const VINEXT_NEXT_CONFIG_PLUGIN_PROPERTY = "__vinextNextConfig";
 * Throws if the parsed value is less than 1.
 */
 function parseBodySizeLimit(value) {
-	if (value === void 0 || value === null) return 1 * 1024 * 1024;
+	if (value === void 0 || value === null) return 1048576;
 	if (typeof value === "number") {
 		if (value < 1) throw new Error(`Body size limit must be a positive number, got ${value}`);
 		return value;
@@ -37,7 +107,7 @@ function parseBodySizeLimit(value) {
 	const match = value.trim().match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb|tb|pb)?$/i);
 	if (!match) {
 		console.warn(`[vinext] Invalid bodySizeLimit value: "${value}". Expected a number or a string like "1mb", "500kb". Falling back to 1MB.`);
-		return 1 * 1024 * 1024;
+		return 1048576;
 	}
 	const num = parseFloat(match[1]);
 	const unit = (match[2] ?? "b").toLowerCase();
@@ -61,7 +131,7 @@ function parseBodySizeLimit(value) {
 		case "pb":
 			bytes = Math.floor(num * 1024 * 1024 * 1024 * 1024 * 1024);
 			break;
-		default: return 1 * 1024 * 1024;
+		default: return 1048576;
 	}
 	if (bytes < 1) throw new Error(`Body size limit must be a positive number, got ${bytes}`);
 	return bytes;
@@ -323,6 +393,9 @@ async function loadConfigViaRequire(configPath, root, phase) {
 * package (the common shape after `vinext init`).
 */
 async function loadNextConfig(root, phase = DEFAULT_PHASE) {
+	return withConfigRoot(root, () => withNextPackageIdentity(() => loadNextConfigWithPackageIdentity(root, phase)));
+}
+async function loadNextConfigWithPackageIdentity(root, phase) {
 	const configPath = findNextConfigPath(root);
 	if (!configPath) return null;
 	const filename = path.basename(configPath);
@@ -454,7 +527,7 @@ function resolveDeploymentId(configDeploymentId) {
 * across plugin instances); otherwise we mint a random UUID.
 *
 * NOTE: like `resolveBuildId`, this is non-deterministic in the no-deploymentId
-* case, so a single `vinext build` that instantiates the plugin more than once
+* case, so a single `vite build` that instantiates the plugin more than once
 * (App Router `buildApp()` + the hybrid Pages Router `vite.build()`) must
 * resolve it once and share it — see `__VINEXT_SHARED_RSC_COMPATIBILITY_ID`.
 */
@@ -704,7 +777,7 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 			turbopackTranspilePackages: [...DEFAULT_TRANSPILED_PACKAGES],
 			inlineCss: false,
 			globalNotFound: false,
-			serverActionsBodySizeLimit: 1 * 1024 * 1024,
+			serverActionsBodySizeLimit: 1048576,
 			serverActionsBodySizeLimitLabel: "1 MB",
 			expireTime: DEFAULT_EXPIRE_TIME,
 			reactMaxHeadersLength: DEFAULT_REACT_MAX_HEADERS_LENGTH,
@@ -726,6 +799,8 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 			compilerDefine: {},
 			compilerDefineServer: {},
 			instrumentationClientInject: [],
+			instrumentationClientRouteManifest: void 0,
+			instrumentationServerValueInjections: {},
 			clientTraceMetadata: void 0,
 			staleTimes: { ...DEFAULT_STALE_TIMES },
 			useLightningcss: false,
@@ -819,8 +894,10 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 	};
 	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 || 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");
+	if (config.webpack !== void 0) {
+		if (mdx || Object.keys(webpackProbe.aliases).length > 0 || webpackProbe.resolveExtensionsCustomized || webpackProbe.instrumentationClientRouteManifest !== void 0) console.warn("[vinext] next.config option \"webpack\" is only partially supported. vinext preserves resolve.alias, resolve.extensions, MDX loader settings, and instrumentation-client route manifests, but other webpack customization is ignored");
+		else console.warn("[vinext] next.config option \"webpack\" is not yet supported and will be ignored");
+	}
 	const output = readOptionalString(config.output) ?? "";
 	if (output && output !== "export" && output !== "standalone") console.warn(`[vinext] Unknown output mode "${output}", ignoring`);
 	const pageExtensions = normalizePageExtensions(config.pageExtensions);
@@ -863,6 +940,8 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 		resolveExtensions: resolveExtensions ?? webpackProbe.resolveExtensions,
 		serverResolveExtensions: resolveExtensions ?? webpackProbe.serverResolveExtensions,
 		instrumentationClientInject: Array.isArray(config.instrumentationClientInject) ? config.instrumentationClientInject.filter((x) => typeof x === "string") : [],
+		instrumentationClientRouteManifest: webpackProbe.instrumentationClientRouteManifest,
+		instrumentationServerValueInjections: webpackProbe.instrumentationServerValueInjections,
 		cacheComponents: config.cacheComponents ?? false,
 		appNavFailHandling: experimental?.appNavFailHandling === true,
 		gestureTransition: experimental?.gestureTransition === true,
@@ -951,7 +1030,9 @@ async function probeWebpackConfig(config, root, dev) {
 		mdx: null,
 		resolveExtensions: null,
 		serverResolveExtensions: null,
-		resolveExtensionsCustomized: false
+		resolveExtensionsCustomized: false,
+		instrumentationClientRouteManifest: void 0,
+		instrumentationServerValueInjections: {}
 	};
 	try {
 		const clientProbe = await runWebpackConfigProbe(config, root, {
@@ -969,7 +1050,9 @@ async function probeWebpackConfig(config, root, dev) {
 			mdx: extractMdxOptionsFromRules(clientProbe.rules),
 			resolveExtensions: clientProbe.resolveExtensions,
 			serverResolveExtensions: serverProbe.resolveExtensions,
-			resolveExtensionsCustomized: clientProbe.resolveExtensions !== null || serverProbe.resolveExtensions !== null
+			resolveExtensionsCustomized: clientProbe.resolveExtensions !== null || serverProbe.resolveExtensions !== null,
+			instrumentationClientRouteManifest: extractInstrumentationClientRouteManifest(clientProbe.rules),
+			instrumentationServerValueInjections: extractInstrumentationServerValueInjections(serverProbe.rules, root)
 		};
 	} catch {
 		return {
@@ -977,10 +1060,69 @@ async function probeWebpackConfig(config, root, dev) {
 			mdx: null,
 			resolveExtensions: null,
 			serverResolveExtensions: null,
-			resolveExtensionsCustomized: false
+			resolveExtensionsCustomized: false,
+			instrumentationClientRouteManifest: void 0,
+			instrumentationServerValueInjections: {}
 		};
 	}
 }
+function isValueInjectionLoader(use) {
+	if (!isUnknownRecord(use) || typeof use.loader !== "string") return false;
+	return /(?:^|[/\\])value-?injection-?loader\.[cm]?[jt]s$/i.test(use.loader);
+}
+function extractInstrumentationClientRouteManifest(rules) {
+	let manifest;
+	const visit = (rule) => {
+		if (!rule || typeof rule !== "object") return;
+		if (Array.isArray(rule)) {
+			for (const child of rule) visit(child);
+			return;
+		}
+		if (Array.isArray(rule.oneOf)) for (const child of rule.oneOf) visit(child);
+		if (Array.isArray(rule.rules)) for (const child of rule.rules) visit(child);
+		const uses = Array.isArray(rule.use) ? rule.use : rule.use ? [rule.use] : [];
+		for (const use of uses) {
+			if (!isValueInjectionLoader(use) || !isUnknownRecord(use.options?.values)) continue;
+			const value = use.options.values._sentryRouteManifest;
+			if (typeof value === "string") manifest = value;
+		}
+	};
+	for (const rule of rules) visit(rule);
+	return manifest;
+}
+function matchesWebpackCondition(condition, value) {
+	if (typeof condition === "string") return value.startsWith(condition);
+	if (condition instanceof RegExp) {
+		condition.lastIndex = 0;
+		const matches = condition.test(value);
+		condition.lastIndex = 0;
+		return matches;
+	}
+	if (Array.isArray(condition)) return condition.some((child) => matchesWebpackCondition(child, value));
+	return false;
+}
+function extractInstrumentationServerValueInjections(rules, root) {
+	const values = {};
+	const candidates = ["instrumentation.ts", "src/instrumentation.ts"].flatMap((candidate) => [candidate, path.join(root, candidate)]);
+	const visit = (rule) => {
+		if (!rule || typeof rule !== "object") return;
+		if (Array.isArray(rule)) {
+			for (const child of rule) visit(child);
+			return;
+		}
+		if (Array.isArray(rule.oneOf)) for (const child of rule.oneOf) visit(child);
+		if (Array.isArray(rule.rules)) for (const child of rule.rules) visit(child);
+		if (!candidates.some((candidate) => matchesWebpackCondition(rule.test, candidate) && (rule.include === void 0 || matchesWebpackCondition(rule.include, candidate)) && (rule.exclude === void 0 || !matchesWebpackCondition(rule.exclude, candidate)))) return;
+		const uses = Array.isArray(rule.use) ? rule.use : rule.use ? [rule.use] : [];
+		for (const use of uses) {
+			if (!isValueInjectionLoader(use)) continue;
+			const injected = use.options?.values;
+			if (isUnknownRecord(injected)) Object.assign(values, injected);
+		}
+	};
+	for (const rule of rules) visit(rule);
+	return values;
+}
 const DEFAULT_WEBPACK_RESOLVE_EXTENSIONS = [
 	".js",
 	".mjs",
@@ -992,6 +1134,9 @@ const DEFAULT_WEBPACK_RESOLVE_EXTENSIONS = [
 ];
 async function runWebpackConfigProbe(config, root, options) {
 	const rules = [];
+	class WebpackPluginStub {
+		constructor(_options) {}
+	}
 	const mockConfig = {
 		context: root,
 		resolve: {
@@ -1002,9 +1147,11 @@ async function runWebpackConfigProbe(config, root, options) {
 		plugins: []
 	};
 	const finalConfig = await config.webpack(mockConfig, {
+		config,
 		defaultLoaders: { babel: { loader: "next-babel-loader" } },
 		...options,
-		dir: root
+		dir: root,
+		webpack: new Proxy({}, { get: () => WebpackPluginStub })
 	}) ?? mockConfig;
 	const finalRules = finalConfig.module?.rules ?? rules;
 	const extensions = Array.isArray(finalConfig.resolve?.extensions) ? readStringArray(finalConfig.resolve.extensions) : null;

package/dist/config/prerender.d.ts

@@ -1,7 +1,7 @@
-import { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, VinextCacheConfig, findVinextCacheConfigInPlugins, loadVinextCacheConfigFromViteConfig } from "../cache/cache-adapters-virtual.js";
+import { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, VinextCacheConfig, cacheWarmupStatusSource, finalizeCacheAdapterPrerenderOutput, findVinextCacheConfigInPlugins, hasBuildIdentityResponseHeader, hasCacheAdapterPrerenderOutput, hasUncachedRequestRouting, hasVerbatimResponseVary, isConfiguredCdnResponsePolicyHeader, loadVinextCacheConfigFromViteConfig, requiresRouteCacheabilityProbeManifest, supportsCanonicalRscWarmup } from "../cache/cache-adapters-virtual.js";
 import { PluginOption } from "vite";
 //#region src/config/prerender.d.ts
-type VinextPrerenderConfig = true | {
+export type VinextPrerenderConfig = true | {
   /**
    * Routes to pre-render after the production build.
    *
@@ -9,18 +9,22 @@ type VinextPrerenderConfig = true | {
    * App Router and Pages Router route that vinext can statically render.
    */
   routes: "*";
+  /** Maximum number of routes to render concurrently. */
+  concurrency?: number;
 };
-type ResolvedVinextPrerenderConfig = {
+export type ResolvedVinextPrerenderConfig = {
   routes: "*";
+  concurrency?: number;
 };
-type VinextPrerenderDecisionReason = "flag" | "next-export" | "vinext-config";
-type VinextPrerenderDecision = ResolvedVinextPrerenderConfig & {
+export type VinextPrerenderDecisionReason = "flag" | "next-export" | "vinext-config";
+export type VinextPrerenderDecision = ResolvedVinextPrerenderConfig & {
   reason: VinextPrerenderDecisionReason;
 };
-declare const VINEXT_PRERENDER_CONFIG_PLUGIN_PROPERTY = "__vinextPrerenderConfig";
-declare const VINEXT_ROUTE_ROOT_CONFIG_PLUGIN_PROPERTY = "__vinextRouteRootConfig";
-type VinextRouteRootConfig = {
+export declare const VINEXT_PRERENDER_CONFIG_PLUGIN_PROPERTY = "__vinextPrerenderConfig";
+export declare const VINEXT_ROUTE_ROOT_CONFIG_PLUGIN_PROPERTY = "__vinextRouteRootConfig";
+export type VinextRouteRootConfig = {
   appDir?: string;
+  clientOutDir?: string;
   disableAppRouter?: boolean;
   rscOutDir?: string;
   ssrOutDir?: string;
@@ -28,16 +32,16 @@ type VinextRouteRootConfig = {
 type ViteConfigLoader = {
   loadConfigFromFile: typeof import("vite").loadConfigFromFile;
 };
-declare function normalizeVinextPrerenderConfig(config: VinextPrerenderConfig | undefined): ResolvedVinextPrerenderConfig | null;
-declare function findVinextPrerenderConfigInPlugins(plugins: PluginOption[] | undefined): Promise<ResolvedVinextPrerenderConfig | null>;
-declare function findVinextRouteRootConfigInPlugins(plugins: PluginOption[] | undefined): Promise<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: {
+export declare function normalizeVinextPrerenderConfig(config: VinextPrerenderConfig | undefined): ResolvedVinextPrerenderConfig | null;
+export declare function findVinextPrerenderConfigInPlugins(plugins: PluginOption[] | undefined): Promise<ResolvedVinextPrerenderConfig | null>;
+export declare function findVinextRouteRootConfigInPlugins(plugins: PluginOption[] | undefined): Promise<VinextRouteRootConfig | null>;
+export declare function loadVinextPrerenderConfigFromViteConfig(vite: ViteConfigLoader, root: string): Promise<ResolvedVinextPrerenderConfig | null>;
+export declare function loadVinextRouteRootConfigFromViteConfig(vite: ViteConfigLoader, root: string): Promise<VinextRouteRootConfig | null>;
+export declare function resolveVinextPrerenderDecision(options: {
   prerenderAllFlag?: boolean;
   vinextPrerenderConfig?: ResolvedVinextPrerenderConfig | null;
   nextOutput?: string;
 }): VinextPrerenderDecision | null;
-declare function formatVinextPrerenderLabel(decision: VinextPrerenderDecision): string;
+export declare function formatVinextPrerenderLabel(decision: VinextPrerenderDecision): string;
 //#endregion
-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 };
+export { VINEXT_CACHE_CONFIG_PLUGIN_PROPERTY, type VinextCacheConfig, cacheWarmupStatusSource, finalizeCacheAdapterPrerenderOutput, findVinextCacheConfigInPlugins, hasBuildIdentityResponseHeader, hasCacheAdapterPrerenderOutput, hasUncachedRequestRouting, hasVerbatimResponseVary, isConfiguredCdnResponsePolicyHeader, loadVinextCacheConfigFromViteConfig, requiresRouteCacheabilityProbeManifest, supportsCanonicalRscWarmup };