vinext 0.0.54 → 0.1.0

package/dist/cloudflare/src/cache/cdn-adapter.runtime.js

@@ -0,0 +1,97 @@
+import { getRequestExecutionContext } from "../../../shims/request-context.js";
+//#region ../cloudflare/src/cache/cdn-adapter.runtime.ts
+function getWorkersCache() {
+	const cache = getRequestExecutionContext()?.cache;
+	if (cache && typeof cache.purge === "function") return cache;
+	return null;
+}
+/** Non-cacheable responses: nobody (edge or browser) stores them. */
+const NO_STORE = "no-store";
+/**
+* Browser-facing policy for cacheable responses. `public` allows shared caches
+* to participate, but `max-age=0, must-revalidate` forces every reuse to
+* revalidate (against the edge) rather than serving a stored copy — so the user
+* always sees edge-fresh content while still permitting conditional 304s.
+*/
+const BROWSER_REVALIDATE = "public, max-age=0, must-revalidate";
+/**
+* A concrete stale window (1 year) substituted for a value-less
+* `stale-while-revalidate`. The framework emits a bare `stale-while-revalidate`
+* (no `=seconds`) to mean an unbounded stale window — a Vercel CDN extension.
+* Cloudflare follows RFC 5861, which requires `stale-while-revalidate=<seconds>`,
+* and treats the value-less form as a zero-width window (no stale serving →
+* hard expiry at `max-age`, so the next request is a MISS instead of UPDATING).
+* Stamping a large finite value preserves the "serve stale ~indefinitely while
+* revalidating" intent in a form the edge honors.
+*/
+const UNBOUNDED_SWR_SECONDS = 31536e3;
+/**
+* Convert the framework's shared-cache policy into a CDN-scoped one:
+* `s-maxage=…` → `max-age=…` (the edge honors `max-age` inside
+* `CDN-Cache-Control`), give a value-less `stale-while-revalidate` an explicit
+* seconds value (Cloudflare ignores the bare directive), and ensure a leading
+* `public`.
+*/
+function toEdgeCacheControl(cacheControl) {
+	const withMaxAge = cacheControl.replace(/\bs-maxage=/g, "max-age=").replace(/\bstale-while-revalidate\b(?!=)/g, `stale-while-revalidate=${UNBOUNDED_SWR_SECONDS}`);
+	return /\bpublic\b/.test(withMaxAge) ? withMaxAge : `public, ${withMaxAge}`;
+}
+/**
+* Cloudflare's `Cache-Tag` header budget is 16 KB total with each tag capped at
+* 1024 bytes. Keep a conservative ceiling so a page with a large tag set never
+* produces an oversized (silently-dropped) header.
+*/
+const MAX_CACHE_TAG_BYTES = 8 * 1024;
+const MAX_SINGLE_TAG_BYTES = 1024;
+/**
+* Build a `Cache-Tag` header value from canonicalised tags. Tags containing a
+* comma (the header separator) or exceeding the per-tag size are skipped, and
+* the whole value is bounded to stay within Cloudflare's limit.
+*/
+function formatCacheTag(tags) {
+	const parts = [];
+	let total = 0;
+	for (const tag of tags) {
+		if (!tag || tag.includes(",") || tag.length > MAX_SINGLE_TAG_BYTES) continue;
+		const next = total + tag.length + (parts.length > 0 ? 1 : 0);
+		if (next > MAX_CACHE_TAG_BYTES) break;
+		parts.push(tag);
+		total = next;
+	}
+	return parts.length > 0 ? parts.join(",") : null;
+}
+var CloudflareCdnCacheAdapter = class {
+	ownsBackgroundRevalidation = false;
+	/**
+	* The origin keeps no page store — return null so the request renders fresh.
+	* The edge serves cached HIT/STALE responses without reaching the origin.
+	*/
+	async get() {
+		return null;
+	}
+	/** No-op: the platform caches the response via its headers, not an origin store. */
+	async set(_key, _data, _ctx) {}
+	buildResponseHeaders(input) {
+		if (!input.cacheControl) return { "Cache-Control": NO_STORE };
+		if (/\b(?:no-store|no-cache|private)\b/.test(input.cacheControl)) return { "Cache-Control": input.cacheControl };
+		const headers = {
+			"Cache-Control": BROWSER_REVALIDATE,
+			"CDN-Cache-Control": toEdgeCacheControl(input.cacheControl)
+		};
+		if (input.tags && input.tags.length > 0) {
+			const cacheTag = formatCacheTag(input.tags);
+			if (cacheTag) headers["Cache-Tag"] = cacheTag;
+		}
+		return headers;
+	}
+	/** Purge edge-cached responses by tag via the request context's `cache.purge`. */
+	async revalidateTag(tags, _durations) {
+		const cache = getWorkersCache();
+		if (!cache) return;
+		const tagList = (Array.isArray(tags) ? tags : [tags]).filter((t) => typeof t === "string" && t.length > 0);
+		if (tagList.length === 0) return;
+		await cache.purge({ tags: tagList });
+	}
+};
+//#endregion
+export { CloudflareCdnCacheAdapter };

package/dist/cloudflare/{kv-cache-handler.d.ts → src/cache/kv-data-adapter.runtime.d.ts}

@@ -1,7 +1,7 @@
-import { ExecutionContextLike } from "../shims/request-context.js";
-import { CacheHandler, CacheHandlerValue, IncrementalCacheValue } from "../shims/cache.js";
+import { ExecutionContextLike } from "../../../shims/request-context.js";
+import { CacheHandler, CacheHandlerValue, IncrementalCacheValue } from "../../../shims/cache.js";
 
-//#region src/cloudflare/kv-cache-handler.d.ts
+//#region ../cloudflare/src/cache/kv-data-adapter.runtime.d.ts
 type KVNamespace = {
   get(key: string, options?: {
     type?: string;
@@ -28,7 +28,27 @@ type KVNamespace = {
   }>;
 };
 /** Key prefix for cache entries. */
-declare const ENTRY_PREFIX = "cache:";
+/**
+ * Cloudflare KV data cache handler.
+ *
+ * @deprecated Consumers should not instantiate or register this handler by
+ * hand. Configure it declaratively via the `cache.data` option on the
+ * `vinext()` plugin, using the {@link kvDataAdapter} builder:
+ *
+ * ```ts
+ * import { vinext } from "vinext";
+ * import { kvDataAdapter } from "@vinext/cloudflare/cache/kv-data-adapter";
+ *
+ * export default defineConfig({
+ *   plugins: [vinext({ cache: { data: kvDataAdapter({ binding: "VINEXT_KV_CACHE" }) } })],
+ * });
+ * ```
+ *
+ * `kvDataAdapter()` is safe to call from `vite.config.ts` — it never touches
+ * the Workers runtime — and the plugin defers instantiation of this handler to
+ * the first request. This class stays exported for the runtime factory and for
+ * backwards compatibility, but is not the recommended consumer API.
+ */
 declare class KVCacheHandler implements CacheHandler {
   private kv;
   private prefix;
@@ -103,5 +123,4 @@ declare class KVCacheHandler implements CacheHandler {
   private _put;
 }
 //#endregion
-export { ENTRY_PREFIX, KVCacheHandler };
-//# sourceMappingURL=kv-cache-handler.d.ts.map
+export { KVCacheHandler };

package/dist/cloudflare/{kv-cache-handler.js → src/cache/kv-data-adapter.runtime.js}

@@ -1,36 +1,25 @@
-import { getRequestExecutionContext } from "../shims/request-context.js";
-import { isUnknownRecord } from "../utils/record.js";
-import { readCacheControlNumberField } from "../utils/cache-control-metadata.js";
+import { getRequestExecutionContext } from "../../../shims/request-context.js";
+import { isUnknownRecord, readCacheControlNumberField } from "../utils/cache-control-metadata.js";
 import { Buffer } from "node:buffer";
-//#region src/cloudflare/kv-cache-handler.ts
+//#region ../cloudflare/src/cache/kv-data-adapter.runtime.ts
 /**
-* Cloudflare KV-backed CacheHandler for vinext.
+* Cloudflare KV data cache — implementation + runtime factory.
 *
-* Provides persistent ISR caching on Cloudflare Workers using KV as the
-* storage backend. Supports time-based expiry (stale-while-revalidate)
-* and tag-based invalidation.
+* `KVCacheHandler` provides persistent ISR caching on Cloudflare Workers using
+* KV as the storage backend (time-based expiry / stale-while-revalidate and
+* tag-based invalidation). The default export is the adapter factory the
+* generated `virtual:vinext-cache-adapters` registration imports: it reads the
+* KV namespace from `env[binding]` at request time and constructs the handler.
 *
-* Usage in worker/index.ts:
-*
-*   import { KVCacheHandler } from "vinext/cloudflare";
-*   import { setCacheHandler } from "vinext/shims/cache";
-*
-*   export default {
-*     async fetch(request: Request, env: Env, ctx: ExecutionContext) {
-*       setCacheHandler(new KVCacheHandler(env.VINEXT_CACHE));
-*       // ctx is propagated automatically via runWithExecutionContext in
-*       // the vinext handler — no need to pass it to KVCacheHandler.
-*       // ... rest of worker handler
-*     }
-*   };
+* Configure it from vite.config via the {@link kvDataAdapter} builder in
+* `./kv-data-adapter.ts` (which `require.resolve`s this file). The legacy
+* imperative path (constructing `KVCacheHandler` and calling
+* `setDataCacheHandler` from a worker entry) is deprecated — prefer the
+* `cache.data` plugin option.
 *
 * Wrangler config (wrangler.jsonc):
 *
-*   {
-*     "kv_namespaces": [
-*       { "binding": "VINEXT_CACHE", "id": "<your-kv-namespace-id>" }
-*     ]
-*   }
+*   { "kv_namespaces": [{ "binding": "VINEXT_KV_CACHE", "id": "<your-kv-namespace-id>" }] }
 */
 /** Key prefix for tag invalidation timestamps. */
 const TAG_PREFIX = "__tag:";
@@ -78,6 +67,27 @@ function isPathChildOf(path, prefix) {
 	if (path === prefix) return true;
 	return path.startsWith(prefix + "/");
 }
+/**
+* Cloudflare KV data cache handler.
+*
+* @deprecated Consumers should not instantiate or register this handler by
+* hand. Configure it declaratively via the `cache.data` option on the
+* `vinext()` plugin, using the {@link kvDataAdapter} builder:
+*
+* ```ts
+* import { vinext } from "vinext";
+* import { kvDataAdapter } from "@vinext/cloudflare/cache/kv-data-adapter";
+*
+* export default defineConfig({
+*   plugins: [vinext({ cache: { data: kvDataAdapter({ binding: "VINEXT_KV_CACHE" }) } })],
+* });
+* ```
+*
+* `kvDataAdapter()` is safe to call from `vite.config.ts` — it never touches
+* the Workers runtime — and the plugin defers instantiation of this handler to
+* the first request. This class stays exported for the runtime factory and for
+* backwards compatibility, but is not the recommended consumer API.
+*/
 var KVCacheHandler = class {
 	kv;
 	prefix;
@@ -423,5 +433,3 @@ function safeBase64ToArrayBuffer(base64) {
 }
 //#endregion
 export { ENTRY_PREFIX, KVCacheHandler };
-
-//# sourceMappingURL=kv-cache-handler.js.map

package/dist/cloudflare/src/utils/cache-control-metadata.js

@@ -0,0 +1,20 @@
+//#region ../cloudflare/src/utils/cache-control-metadata.ts
+/**
+* Small internal helpers for reading cache-control metadata off the loosely
+* typed `ctx` object the cache layer passes around. Kept local to this package
+* so the Cloudflare adapters stay self-contained (these mirror the equivalent
+* helpers in the vinext core).
+*/
+function isUnknownRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readRecordField(ctx, field) {
+	const value = ctx?.[field];
+	return isUnknownRecord(value) ? value : void 0;
+}
+function readCacheControlNumberField(ctx, field) {
+	const value = readRecordField(ctx, "cacheControl")?.[field] ?? ctx?.[field];
+	return typeof value === "number" ? value : void 0;
+}
+//#endregion
+export { isUnknownRecord, readCacheControlNumberField };

package/dist/cloudflare/tpr.d.ts

@@ -45,7 +45,7 @@ type WranglerConfig = {
 };
 /**
  * Parse wrangler config (JSONC or TOML) to extract the fields TPR needs:
- * account_id, VINEXT_CACHE KV namespace ID, and custom domain.
+ * account_id, VINEXT_KV_CACHE KV namespace ID, and custom domain.
  */
 declare function parseWranglerConfig(root: string): WranglerConfig | null;
 /**
@@ -79,5 +79,4 @@ declare function buildTprKVPairs(entries: Map<string, PrerenderResult>, buildId:
  */
 declare function runTPR(options: TPROptions): Promise<TPRResult>;
 //#endregion
-export { TPROptions, TPRResult, buildTprKVPairs, domainCandidates, parseWranglerConfig, runTPR };
-//# sourceMappingURL=tpr.d.ts.map
+export { TPROptions, TPRResult, buildTprKVPairs, domainCandidates, parseWranglerConfig, runTPR };

package/dist/cloudflare/tpr.js

@@ -1,6 +1,7 @@
 import { VINEXT_REVALIDATE_HEADER } from "../server/headers.js";
 import { isrCacheKey } from "../server/isr-cache.js";
-import { ENTRY_PREFIX } from "./kv-cache-handler.js";
+import { buildAppPageCacheTags } from "../server/app-page-cache.js";
+import { ENTRY_PREFIX } from "./src/cache/kv-data-adapter.runtime.js";
 import fs from "node:fs";
 import path from "node:path";
 import { spawn } from "node:child_process";
@@ -28,7 +29,7 @@ import { spawn } from "node:child_process";
 */
 /**
 * Parse wrangler config (JSONC or TOML) to extract the fields TPR needs:
-* account_id, VINEXT_CACHE KV namespace ID, and custom domain.
+* account_id, VINEXT_KV_CACHE KV namespace ID, and custom domain.
 */
 function parseWranglerConfig(root) {
 	for (const filename of ["wrangler.jsonc", "wrangler.json"]) {
@@ -111,7 +112,7 @@ function extractFromJSON(config) {
 	const result = {};
 	if (typeof config.account_id === "string") result.accountId = config.account_id;
 	if (Array.isArray(config.kv_namespaces)) {
-		const vinextKV = config.kv_namespaces.find((ns) => ns && typeof ns === "object" && ns.binding === "VINEXT_CACHE");
+		const vinextKV = config.kv_namespaces.find((ns) => ns && typeof ns === "object" && (ns.binding === "VINEXT_KV_CACHE" || ns.binding === "VINEXT_CACHE"));
 		if (vinextKV && typeof vinextKV.id === "string" && vinextKV.id !== "<your-kv-namespace-id>") result.kvNamespaceId = vinextKV.id;
 	}
 	const domain = extractDomainFromRoutes(config.routes) ?? extractDomainFromCustomDomains(config);
@@ -156,7 +157,7 @@ function extractFromTOML(content) {
 		const block = kvBlocks[i].split(/\[\[/)[0];
 		const bindingMatch = block.match(/binding\s*=\s*"([^"]+)"/);
 		const idMatch = block.match(/\bid\s*=\s*"([^"]+)"/);
-		if (bindingMatch?.[1] === "VINEXT_CACHE" && idMatch?.[1] && idMatch[1] !== "<your-kv-namespace-id>") result.kvNamespaceId = idMatch[1];
+		if ((bindingMatch?.[1] === "VINEXT_KV_CACHE" || bindingMatch?.[1] === "VINEXT_CACHE") && idMatch?.[1] && idMatch[1] !== "<your-kv-namespace-id>") result.kvNamespaceId = idMatch[1];
 	}
 	const routeMatch = content.match(/^route\s*=\s*"([^"]+)"/m);
 	if (routeMatch) {
@@ -427,6 +428,7 @@ function buildTprKVPairs(entries, buildId, defaultRevalidateSeconds) {
 		const revalidateSeconds = revalidateHeader && !isNaN(Number(revalidateHeader)) ? Number(revalidateHeader) : defaultRevalidateSeconds;
 		const revalidateAt = revalidateSeconds > 0 ? now + revalidateSeconds * 1e3 : null;
 		const kvTtl = revalidateSeconds > 0 ? MAX_KV_TTL_SECONDS : 24 * 3600;
+		const tags = buildAppPageCacheTags(routePath, []);
 		const entry = {
 			value: {
 				kind: "APP_PAGE",
@@ -434,7 +436,7 @@ function buildTprKVPairs(entries, buildId, defaultRevalidateSeconds) {
 				headers: result.headers,
 				status: result.status
 			},
-			tags: [],
+			tags,
 			lastModified: now,
 			revalidateAt
 		};
@@ -494,7 +496,7 @@ async function runTPR(options) {
 	const wranglerConfig = parseWranglerConfig(root);
 	if (!wranglerConfig) return skip("could not parse wrangler config");
 	if (!wranglerConfig.customDomain) return skip("no custom domain — zone analytics unavailable");
-	if (!wranglerConfig.kvNamespaceId) return skip("no VINEXT_CACHE KV namespace configured");
+	if (!wranglerConfig.kvNamespaceId) return skip("no VINEXT_KV_CACHE KV namespace configured");
 	const accountId = wranglerConfig.accountId ?? await resolveAccountId(apiToken);
 	if (!accountId) return skip("could not resolve Cloudflare account ID");
 	console.log(`  TPR: Analyzing traffic for ${wranglerConfig.customDomain} (last ${windowHours}h)`);
@@ -554,5 +556,3 @@ async function runTPR(options) {
 }
 //#endregion
 export { buildTprKVPairs, domainCandidates, parseWranglerConfig, runTPR };
-
-//# sourceMappingURL=tpr.js.map

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

@@ -218,5 +218,4 @@ declare function applyLocaleToRoutes<T extends NextRedirect | NextRewrite>(route
   trailingSlash?: boolean;
 }): T[];
 //#endregion
-export { BasePathMatchState, RequestContext, applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, escapeHeaderSource, isExternalUrl, isSafeRegex, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, normalizeHost, parseCookies, proxyExternalRequest, requestContextFromRequest, safeRegExp, sanitizeDestination };
-//# sourceMappingURL=config-matchers.d.ts.map
+export { BasePathMatchState, RequestContext, applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, escapeHeaderSource, isExternalUrl, isSafeRegex, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, normalizeHost, parseCookies, proxyExternalRequest, requestContextFromRequest, safeRegExp, sanitizeDestination };

package/dist/config/config-matchers.js

@@ -926,5 +926,3 @@ function applyLocaleToRoutes(routes, i18n, type, options = {}) {
 }
 //#endregion
 export { applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, escapeHeaderSource, isExternalUrl, isSafeRegex, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, normalizeHost, parseCookies, proxyExternalRequest, requestContextFromRequest, safeRegExp, sanitizeDestination };
-
-//# sourceMappingURL=config-matchers.js.map

package/dist/config/dotenv.d.ts

@@ -53,5 +53,4 @@ declare function loadDotenv({
   processEnv
 }: LoadDotenvOptions): LoadDotenvResult;
 //#endregion
-export { getDotenvFiles, loadDotenv };
-//# sourceMappingURL=dotenv.d.ts.map
+export { getDotenvFiles, loadDotenv };

package/dist/config/dotenv.js

@@ -86,5 +86,3 @@ function expandEnv(parsed, processEnv) {
 }
 //#endregion
 export { getDotenvFiles, loadDotenv };
-
-//# sourceMappingURL=dotenv.js.map

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

@@ -223,6 +223,12 @@ type ResolvedNextConfig = {
   pageExtensions: string[];
   instrumentationClientInject: string[];
   cacheComponents: 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.
+   */
+  prefetchInlining: boolean;
   redirects: NextRedirect[];
   rewrites: {
     beforeFiles: NextRewrite[];
@@ -247,7 +253,14 @@ type ResolvedNextConfig = {
    * `experimental.serverComponentsExternalPackages` in next.config.
    */
   serverExternalPackages: string[]; /** Enable sourcemaps for prerender error stack traces. Defaults to true. */
-  enablePrerenderSourceMaps: boolean; /** Resolved build ID (from generateBuildId, or a random UUID if not provided). */
+  enablePrerenderSourceMaps: boolean;
+  /**
+   * Enable App Shell prefetching (from experimental.appShells).
+   * Plumbing-only in vinext — the flag is accepted and forwarded to the client
+   * bundle via `process.env.__NEXT_APP_SHELLS`, but actual App Shell behavior
+   * requires the segment-cache architecture which is not yet implemented.
+   */
+  appShells: boolean; /** Resolved build ID (from generateBuildId, or a random UUID if not provided). */
   buildId: string; /** Resolved deployment ID from next.config.js or NEXT_DEPLOYMENT_ID. */
   deploymentId: string | undefined;
   /**
@@ -403,6 +416,21 @@ 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;
+/**
+ * Resolve the App Router RSC compatibility identity for a build.
+ *
+ * This token is baked into the client bundle and echoed by the server in the
+ * `X-Vinext-RSC-Compatibility-Id` response header; browser navigation rejects
+ * RSC payloads whose token differs (deploy skew) without exposing the raw
+ * build ID. When the user pins a `deploymentId` we reuse it (already stable
+ * across plugin instances); otherwise we mint a random UUID.
+ *
+ * NOTE: like `resolveBuildId`, this is non-deterministic in the no-deploymentId
+ * case, so a single `vinext 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;
 /**
  * Resolve a NextConfig into a fully-resolved ResolvedNextConfig.
  * Awaits async functions for redirects/rewrites/headers.
@@ -435,5 +463,4 @@ declare function extractMdxOptions(config: NextConfig, root?: string): Promise<M
  */
 declare function detectNextIntlConfig(root: string, resolved: ResolvedNextConfig): void;
 //#endregion
-export { HasCondition, MdxOptions, NextConfig, NextConfigFactory, NextConfigInput, NextHeader, NextI18nConfig, NextRedirect, NextRewrite, PHASE_PRODUCTION_BUILD, ResolvedNextConfig, detectNextIntlConfig, extractMdxOptions, findNextConfigPath, loadNextConfig, normalizeAssetPrefix, parseBodySizeLimit, reassignsModuleExports, referencesCjsGlobals, resolveNextConfig, resolveNextConfigInput };
-//# sourceMappingURL=next-config.d.ts.map
+export { HasCondition, MdxOptions, NextConfig, NextConfigInput, NextHeader, NextI18nConfig, NextRedirect, NextRewrite, PHASE_PRODUCTION_BUILD, ResolvedNextConfig, createRscCompatibilityId, detectNextIntlConfig, extractMdxOptions, findNextConfigPath, loadNextConfig, normalizeAssetPrefix, parseBodySizeLimit, reassignsModuleExports, referencesCjsGlobals, resolveNextConfig, resolveNextConfigInput };

package/dist/config/next-config.js

@@ -3,7 +3,8 @@ 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 { loadTsconfigPathAliasesForRoot } from "./tsconfig-paths.js";
+import { loadTsconfigResolutionForRoot } from "./tsconfig-paths.js";
+import { getViteMajorVersion } from "../utils/vite-version.js";
 import { createRequire } from "node:module";
 import fs from "node:fs";
 import path from "node:path";
@@ -223,12 +224,15 @@ function cjsGlobalsInjectorPlugin(configPath) {
 			const filenameLiteral = JSON.stringify(normalizedTarget);
 			const dirnameLiteral = JSON.stringify(dirname);
 			const requireBaseLiteral = JSON.stringify(path.join(dirname, "package.json"));
+			const hasOwnDirname = /\b(?:const|let|var)\s+__dirname\b/.test(code);
+			const hasOwnFilename = /\b(?:const|let|var)\s+__filename\b/.test(code);
+			const hasOwnRequire = /\b(?:const|let|var)\s+require\b/.test(code);
 			const moduleLines = reassignsModuleExports(code) ? `const __vinextInitialExports = {};
 const module = { exports: __vinextInitialExports };
 const exports = module.exports;
 export const ${VINEXT_CJS_EXPORTS_KEY} = module;\nexport const ${VINEXT_CJS_INITIAL_KEY} = __vinextInitialExports;\n` : "";
 			return {
-				code: `import { createRequire as __vinextCreateRequire } from "node:module";\nconst __filename = ${filenameLiteral};\nconst __dirname = ${dirnameLiteral};\nconst require = __vinextCreateRequire(${requireBaseLiteral});\n` + moduleLines + code,
+				code: (hasOwnRequire ? "" : `import { createRequire as __vinextCreateRequire } from "node:module";\n`) + (hasOwnFilename ? "" : `const __filename = ${filenameLiteral};\n`) + (hasOwnDirname ? "" : `const __dirname = ${dirnameLiteral};\n`) + (hasOwnRequire ? "" : `const require = __vinextCreateRequire(${requireBaseLiteral});\n`) + moduleLines + code,
 				map: null
 			};
 		}
@@ -291,7 +295,9 @@ async function loadNextConfig(root, phase = DEFAULT_PHASE) {
 	const configPath = findNextConfigPath(root);
 	if (!configPath) return null;
 	const filename = path.basename(configPath);
-	const tsconfigAliases = loadTsconfigPathAliasesForRoot(root);
+	const isTypeScriptConfig = /\.[cm]?ts$/.test(configPath);
+	const tsconfigResolution = loadTsconfigResolutionForRoot(root);
+	const useNativeTsconfigPaths = !!(isTypeScriptConfig ? tsconfigResolution.baseUrl : null) && getViteMajorVersion() >= 8;
 	const normalizedConfigPath = safeRealpath(path.resolve(configPath));
 	try {
 		const { runnerImport } = await import("vite");
@@ -300,7 +306,8 @@ async function loadNextConfig(root, phase = DEFAULT_PHASE) {
 			logLevel: "error",
 			clearScreen: false,
 			resolve: {
-				alias: tsconfigAliases,
+				alias: tsconfigResolution.aliases,
+				...useNativeTsconfigPaths ? { tsconfigPaths: true } : {},
 				extensions: [
 					".mjs",
 					".js",
@@ -313,7 +320,7 @@ async function loadNextConfig(root, phase = DEFAULT_PHASE) {
 					".json"
 				]
 			},
-			plugins: [.../\.[cm]?ts$/.test(configPath) ? [cjsGlobalsInjectorPlugin(configPath)] : [], commonjs({ filter: (id) => {
+			plugins: [...isTypeScriptConfig ? [cjsGlobalsInjectorPlugin(configPath)] : [], commonjs({ filter: (id) => {
 				const idPath = id.startsWith("file://") ? fileURLToPath(id) : id.split("?")[0];
 				if (safeRealpath(path.resolve(idPath)) === normalizedConfigPath) return false;
 				return id.includes("node_modules") ? true : void 0;
@@ -390,6 +397,24 @@ function resolveDeploymentId(configDeploymentId) {
 	return deploymentId;
 }
 /**
+* Resolve the App Router RSC compatibility identity for a build.
+*
+* This token is baked into the client bundle and echoed by the server in the
+* `X-Vinext-RSC-Compatibility-Id` response header; browser navigation rejects
+* RSC payloads whose token differs (deploy skew) without exposing the raw
+* build ID. When the user pins a `deploymentId` we reuse it (already stable
+* across plugin instances); otherwise we mint a random UUID.
+*
+* NOTE: like `resolveBuildId`, this is non-deterministic in the no-deploymentId
+* case, so a single `vinext 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`.
+*/
+function createRscCompatibilityId(nextConfig) {
+	if (nextConfig.deploymentId) return nextConfig.deploymentId;
+	return randomUUID();
+}
+/**
 * Converts a cache handler path to a filesystem path.
 * ESM's import.meta.resolve() returns file:// URLs which break when concatenated
 * with path operations like path.join or path.relative.
@@ -481,6 +506,7 @@ async function resolveNextConfig(config, root = process.cwd()) {
 			output: "",
 			pageExtensions: normalizePageExtensions(),
 			cacheComponents: false,
+			prefetchInlining: false,
 			redirects: [],
 			rewrites: {
 				beforeFiles: [],
@@ -503,6 +529,7 @@ async function resolveNextConfig(config, root = process.cwd()) {
 			cacheHandler: void 0,
 			cacheMaxMemorySize: void 0,
 			enablePrerenderSourceMaps: true,
+			appShells: false,
 			hashSalt: process.env.NEXT_HASH_SALT ?? "",
 			buildId,
 			deploymentId,
@@ -567,11 +594,23 @@ async function resolveNextConfig(config, root = process.cwd()) {
 	const rawOptimize = experimental?.optimizePackageImports;
 	const optimizePackageImports = Array.isArray(rawOptimize) ? rawOptimize.filter((x) => typeof x === "string") : [];
 	const inlineCss = experimental?.inlineCss === true;
+	const prefetchInlining = experimental?.prefetchInlining === true || isUnknownRecord(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 (experimental?.varyParams !== true) missingCoFlags.push("experimental.varyParams");
+		if (experimental?.optimisticRouting !== true) missingCoFlags.push("experimental.optimisticRouting");
+		if (experimental?.cachedNavigations !== true) missingCoFlags.push("experimental.cachedNavigations");
+		if (missingCoFlags.length > 0) console.warn(`[vinext] experimental.appShells is enabled but requires the following co-flags which are not yet supported or not enabled: ${missingCoFlags.join(", ")}. App Shell prefetching behavior is not implemented in vinext (see issue #1614). The flag will be accepted for config compatibility but has no functional effect.`);
+	}
 	const topLevelServerExternalPackages = Array.isArray(config.serverExternalPackages) ? readStringArray(config.serverExternalPackages) : void 0;
 	const legacyServerComponentsExternal = readStringArray(experimental?.serverComponentsExternalPackages);
 	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).");
+	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");
 	else console.warn("[vinext] next.config option \"webpack\" is not yet supported and will be ignored");
 	const output = readOptionalString(config.output) ?? "";
@@ -606,6 +645,7 @@ async function resolveNextConfig(config, root = process.cwd()) {
 		pageExtensions,
 		instrumentationClientInject: Array.isArray(config.instrumentationClientInject) ? config.instrumentationClientInject.filter((x) => typeof x === "string") : [],
 		cacheComponents: config.cacheComponents ?? false,
+		prefetchInlining,
 		redirects,
 		rewrites,
 		headers,
@@ -624,6 +664,7 @@ async function resolveNextConfig(config, root = process.cwd()) {
 		cacheHandler,
 		cacheMaxMemorySize,
 		enablePrerenderSourceMaps: config.enablePrerenderSourceMaps ?? true,
+		appShells,
 		hashSalt,
 		buildId,
 		deploymentId,
@@ -861,6 +902,4 @@ function extractPluginsFromOptions(opts) {
 	return null;
 }
 //#endregion
-export { PHASE_PRODUCTION_BUILD, detectNextIntlConfig, extractMdxOptions, findNextConfigPath, loadNextConfig, normalizeAssetPrefix, parseBodySizeLimit, reassignsModuleExports, referencesCjsGlobals, resolveNextConfig, resolveNextConfigInput };
-
-//# sourceMappingURL=next-config.js.map
+export { PHASE_PRODUCTION_BUILD, createRscCompatibilityId, detectNextIntlConfig, extractMdxOptions, findNextConfigPath, loadNextConfig, normalizeAssetPrefix, parseBodySizeLimit, reassignsModuleExports, referencesCjsGlobals, resolveNextConfig, resolveNextConfigInput };

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

@@ -1,13 +1,21 @@
 //#region src/config/tsconfig-paths.d.ts
+type TsconfigPathResolution = {
+  aliases: Record<string, string>;
+  baseUrl: string | null;
+};
 /**
  * Read the project's tsconfig.json (or jsconfig.json) and return its
- * `compilerOptions.paths` as absolute-path Vite `resolve.alias` entries.
+ * path-resolution settings as absolute paths.
  *
- * Returns an empty object if no config is found or no paths are configured.
+ * Returns an empty resolution if no config is found or no relevant compiler
+ * options are configured.
  * Errors during parsing are swallowed — this is a best-effort helper that
  * must not break config loading.
  */
+declare function loadTsconfigResolutionForRoot(projectRoot: string): TsconfigPathResolution;
+/**
+ * Back-compat helper for call sites that only need `compilerOptions.paths`.
+ */
 declare function loadTsconfigPathAliasesForRoot(projectRoot: string): Record<string, string>;
 //#endregion
-export { loadTsconfigPathAliasesForRoot };
-//# sourceMappingURL=tsconfig-paths.d.ts.map
+export { loadTsconfigPathAliasesForRoot, loadTsconfigResolutionForRoot };