vinext 0.0.55 → 0.1.1

package/dist/client/window-next.d.ts

@@ -162,5 +162,4 @@ type WindowNext = {
  */
 declare function installWindowNext(fields: Partial<WindowNext>): void;
 //#endregion
-export { PagesRouterPublicInstance, installWindowNext };
-//# sourceMappingURL=window-next.d.ts.map
+export { PagesRouterPublicInstance, installWindowNext };

package/dist/client/window-next.js

@@ -44,5 +44,3 @@ function installWindowNext(fields) {
 }
 //#endregion
 export { installWindowNext };
-
-//# sourceMappingURL=window-next.js.map

package/dist/cloudflare/index.d.ts

@@ -1,3 +1,3 @@
-import { KVCacheHandler } from "./kv-cache-handler.js";
+import { KVCacheHandler } from "./src/cache/kv-data-adapter.runtime.js";
 import { TPROptions, TPRResult, runTPR } from "./tpr.js";
 export { KVCacheHandler, type TPROptions, type TPRResult, runTPR };

package/dist/cloudflare/index.js

@@ -1,3 +1,3 @@
-import { KVCacheHandler } from "./kv-cache-handler.js";
+import { KVCacheHandler } from "./src/cache/kv-data-adapter.runtime.js";
 import { runTPR } from "./tpr.js";
 export { KVCacheHandler, runTPR };

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

@@ -159,6 +159,25 @@ declare function sanitizeDestination(dest: string): string;
  * per RFC 3986, plus protocol-relative URLs (//).
  */
 declare function isExternalUrl(url: string): boolean;
+/**
+ * Merge the original request's query params into a config-redirect
+ * destination, preserving them on the resulting `Location`.
+ *
+ * Next.js carries the original request query across config redirects
+ * (`prepareDestination({ query: parsedUrl.query })` →
+ * `stringifyQuery(...)` in resolve-routes.ts). This matters for App Router
+ * RSC client navigations: the cache-busting `_rsc` query must survive the
+ * redirect so the browser's auto-followed request to the destination is
+ * still treated as an RSC fetch. Dropping it breaks RSC fetch semantics
+ * (issue #1529).
+ *
+ * Destination query params win — a request param is only carried over when
+ * the destination does not already specify that key. Mirrors the merge
+ * semantics in `proxyExternalRequest`. External destinations are returned
+ * untouched (a config redirect to another origin should not leak the
+ * original request's query).
+ */
+declare function preserveRedirectDestinationQuery(destination: string, requestSearch: string): string;
 /**
  * Proxy an incoming request to an external URL and return the upstream response.
  *
@@ -218,5 +237,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, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, safeRegExp, sanitizeDestination };

package/dist/config/config-matchers.js

@@ -764,6 +764,40 @@ function isExternalUrl(url) {
 	return /^[a-z][a-z0-9+.-]*:/i.test(url) || url.startsWith("//");
 }
 /**
+* Merge the original request's query params into a config-redirect
+* destination, preserving them on the resulting `Location`.
+*
+* Next.js carries the original request query across config redirects
+* (`prepareDestination({ query: parsedUrl.query })` →
+* `stringifyQuery(...)` in resolve-routes.ts). This matters for App Router
+* RSC client navigations: the cache-busting `_rsc` query must survive the
+* redirect so the browser's auto-followed request to the destination is
+* still treated as an RSC fetch. Dropping it breaks RSC fetch semantics
+* (issue #1529).
+*
+* Destination query params win — a request param is only carried over when
+* the destination does not already specify that key. Mirrors the merge
+* semantics in `proxyExternalRequest`. External destinations are returned
+* untouched (a config redirect to another origin should not leak the
+* original request's query).
+*/
+function preserveRedirectDestinationQuery(destination, requestSearch) {
+	if (requestSearch === "" || requestSearch === "?" || isExternalUrl(destination)) return destination;
+	const requestParams = new URLSearchParams(requestSearch);
+	if ([...requestParams.keys()].length === 0) return destination;
+	const hashIndex = destination.indexOf("#");
+	const hash = hashIndex === -1 ? "" : destination.slice(hashIndex);
+	const beforeHash = hashIndex === -1 ? destination : destination.slice(0, hashIndex);
+	const queryIndex = beforeHash.indexOf("?");
+	const pathPart = queryIndex === -1 ? beforeHash : beforeHash.slice(0, queryIndex);
+	const destQuery = queryIndex === -1 ? "" : beforeHash.slice(queryIndex + 1);
+	const merged = new URLSearchParams(destQuery);
+	const destKeys = new Set(merged.keys());
+	for (const [key, value] of requestParams) if (!destKeys.has(key)) merged.append(key, value);
+	const mergedQuery = merged.toString();
+	return mergedQuery === "" ? `${pathPart}${hash}` : `${pathPart}?${mergedQuery}${hash}`;
+}
+/**
 * Proxy an incoming request to an external URL and return the upstream response.
 *
 * Used for external rewrites (e.g. `/ph/:path*` → `https://us.i.posthog.com/:path*`).
@@ -925,6 +959,4 @@ function applyLocaleToRoutes(routes, i18n, type, options = {}) {
 	return out;
 }
 //#endregion
-export { applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, escapeHeaderSource, isExternalUrl, isSafeRegex, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, normalizeHost, parseCookies, proxyExternalRequest, requestContextFromRequest, safeRegExp, sanitizeDestination };
-
-//# sourceMappingURL=config-matchers.js.map
+export { applyLocaleToRoutes, applyMiddlewareRequestHeaders, checkHasConditions, escapeHeaderSource, isExternalUrl, isSafeRegex, matchConfigPattern, matchHeaders, matchRedirect, matchRewrite, normalizeHost, parseCookies, preserveRedirectDestinationQuery, proxyExternalRequest, requestContextFromRequest, safeRegExp, sanitizeDestination };

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

@@ -132,7 +132,14 @@ type NextConfig = {
    */
   instrumentationClientInject?: string[]; /** Extra origins allowed to access the dev server. */
   allowedDevOrigins?: string[]; /** Maximum age in seconds for stale ISR entries before blocking regeneration. */
-  expireTime?: number; /** User agents that require blocking metadata in the initial head. */
+  expireTime?: number;
+  /**
+   * Maximum total length (in characters) of the preload `Link` header emitted
+   * during App Router SSR. React drops whole entries once the limit is
+   * exceeded; `0` disables emission entirely. Defaults to 6000.
+   * @see https://nextjs.org/docs/app/api-reference/config/next-config-js/reactMaxHeadersLength
+   */
+  reactMaxHeadersLength?: number; /** User agents that require blocking metadata in the initial head. */
   htmlLimitedBots?: RegExp | string;
   /**
    * Enable Cache Components (Next.js 16).
@@ -244,8 +251,14 @@ type ResolvedNextConfig = {
   serverActionsAllowedOrigins: string[]; /** Packages whose barrel imports should be optimized (from experimental.optimizePackageImports). */
   optimizePackageImports: string[]; /** Inline app CSS into production HTML (from experimental.inlineCss). */
   inlineCss: boolean; /** Parsed body size limit for server actions in bytes (from experimental.serverActions.bodySizeLimit). Defaults to 1MB. */
-  serverActionsBodySizeLimit: number; /** Route-level expire fallback in seconds for ISR entries with numeric revalidate. */
-  expireTime: number; /** Serialized htmlLimitedBots regexp source from next.config. */
+  serverActionsBodySizeLimit: number; /** Verbatim body size limit config value (e.g. "2mb") for the "Body exceeded {limit} limit" error. Defaults to "1 MB". */
+  serverActionsBodySizeLimitLabel: string; /** Route-level expire fallback in seconds for ISR entries with numeric revalidate. */
+  expireTime: number;
+  /**
+   * Maximum total length (in characters) of the preload `Link` header emitted
+   * during App Router SSR. `0` disables emission. Defaults to 6000.
+   */
+  reactMaxHeadersLength: number; /** Serialized htmlLimitedBots regexp source from next.config. */
   htmlLimitedBots: string | undefined;
   /**
    * Packages that should be treated as server-external (not bundled by Vite).
@@ -416,6 +429,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.
@@ -448,5 +476,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

@@ -72,6 +72,12 @@ const CONFIG_FILES = [
 ];
 const DEFAULT_EXPIRE_TIME = 31536e3;
 /**
+* Default cap for the App Router preload `Link` header length, matching the
+* Next.js `defaultConfig.reactMaxHeadersLength`.
+* @see https://nextjs.org/docs/app/api-reference/config/next-config-js/reactMaxHeadersLength
+*/
+const DEFAULT_REACT_MAX_HEADERS_LENGTH = 6e3;
+/**
 * Check whether an error indicates a CJS module was loaded in an ESM context
 * (i.e. the file uses `require()` which is not available in ESM).
 */
@@ -224,12 +230,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
 			};
 		}
@@ -394,6 +403,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.
@@ -502,7 +529,9 @@ async function resolveNextConfig(config, root = process.cwd()) {
 			optimizePackageImports: [],
 			inlineCss: false,
 			serverActionsBodySizeLimit: 1 * 1024 * 1024,
+			serverActionsBodySizeLimitLabel: "1 MB",
 			expireTime: DEFAULT_EXPIRE_TIME,
+			reactMaxHeadersLength: DEFAULT_REACT_MAX_HEADERS_LENGTH,
 			htmlLimitedBots: void 0,
 			serverExternalPackages: [],
 			cacheHandler: void 0,
@@ -567,7 +596,9 @@ async function resolveNextConfig(config, root = process.cwd()) {
 	const experimental = readOptionalRecord(config.experimental);
 	const serverActionsConfig = readOptionalRecord(experimental?.serverActions);
 	const serverActionsAllowedOrigins = readStringArray(serverActionsConfig?.allowedOrigins);
-	const serverActionsBodySizeLimit = parseBodySizeLimit(readOptionalBodySizeLimit(serverActionsConfig?.bodySizeLimit));
+	const serverActionsBodySizeLimitConfig = readOptionalBodySizeLimit(serverActionsConfig?.bodySizeLimit);
+	const serverActionsBodySizeLimit = parseBodySizeLimit(serverActionsBodySizeLimitConfig);
+	const serverActionsBodySizeLimitLabel = serverActionsBodySizeLimitConfig === void 0 ? "1 MB" : String(serverActionsBodySizeLimitConfig);
 	const hashSalt = (readOptionalString(experimental?.outputHashSalt) ?? "") + (process.env.NEXT_HASH_SALT ?? "");
 	const htmlLimitedBots = resolveHtmlLimitedBots(config.htmlLimitedBots);
 	const rawOptimize = experimental?.optimizePackageImports;
@@ -637,7 +668,9 @@ async function resolveNextConfig(config, root = process.cwd()) {
 		optimizePackageImports,
 		inlineCss,
 		serverActionsBodySizeLimit,
+		serverActionsBodySizeLimitLabel,
 		expireTime: typeof config.expireTime === "number" ? config.expireTime : DEFAULT_EXPIRE_TIME,
+		reactMaxHeadersLength: typeof config.reactMaxHeadersLength === "number" ? config.reactMaxHeadersLength : DEFAULT_REACT_MAX_HEADERS_LENGTH,
 		htmlLimitedBots,
 		serverExternalPackages,
 		cacheHandler,
@@ -659,12 +692,28 @@ async function resolveNextConfig(config, root = process.cwd()) {
 	if (resolved.basePath !== "" && resolved.basePath !== "/" && resolved.assetPrefix === "") resolved.assetPrefix = resolved.basePath;
 	return resolved;
 }
+/**
+* Whether an alias target is a relative filesystem path (`./foo`, `../foo`,
+* or a bare `.`/`..`) that should be resolved against the project root.
+*
+* Both Next.js Turbopack `resolveAlias` and webpack `resolve.alias` accept two
+* kinds of values: relative/absolute file paths AND bare package specifiers
+* (e.g. `react`, `preact/compat`, `@scope/pkg`). Bare specifiers must be left
+* verbatim so Vite/Rolldown re-resolves them through node_modules — resolving
+* them against `root` mangles them into bogus `<root>/react` paths and breaks
+* the build with "No such file or directory". See cloudflare/vinext#1507.
+*/
+function isRelativeAliasTarget(value) {
+	return value === "." || value === ".." || value.startsWith("./") || value.startsWith("../");
+}
 function normalizeAliasEntries(aliases, root) {
 	if (!aliases) return {};
 	const normalized = {};
 	for (const [key, value] of Object.entries(aliases)) {
 		if (typeof value !== "string") continue;
-		normalized[key] = path.isAbsolute(value) ? value : path.resolve(root, value);
+		if (path.isAbsolute(value)) normalized[key] = value;
+		else if (isRelativeAliasTarget(value)) normalized[key] = path.resolve(root, value);
+		else normalized[key] = value;
 	}
 	return normalized;
 }
@@ -881,6 +930,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 };