vinext 1.0.0 → 1.1.0

package/dist/shims/internal/headers-state.js

@@ -0,0 +1,157 @@
+import { getOrCreateAls } from "./als-registry.js";
+import { ensureRenderDynamicLatch, getRequestContext, isInsideUnifiedScope } from "../unified-request-context.js";
+//#region src/shims/internal/headers-state.ts
+function createRenderDynamicLatch() {
+	return {
+		dynamic: false,
+		listeners: /* @__PURE__ */ new Set()
+	};
+}
+const _FALLBACK_KEY = Symbol.for("vinext.nextHeadersShim.fallback");
+const _g = globalThis;
+const headersShimAls = getOrCreateAls("vinext.nextHeadersShim.als");
+const _fallbackState = _g[_FALLBACK_KEY] ??= {
+	headersContext: null,
+	dynamicUsageDetected: false,
+	renderDynamicLatch: createRenderDynamicLatch(),
+	renderRequestApiUsage: /* @__PURE__ */ new Set(),
+	connectionProbe: null,
+	invalidDynamicUsageError: null,
+	pendingSetCookies: [],
+	draftModeCookieHeader: null,
+	phase: "render"
+};
+function getHeadersShimState() {
+	if (isInsideUnifiedScope()) return getRequestContext();
+	return headersShimAls.getStore() ?? _fallbackState;
+}
+/**
+* Dynamic usage flag — set when a component calls connection(), cookies(),
+* headers(), or noStore() during rendering. When true, ISR caching is
+* bypassed and the response gets Cache-Control: no-store.
+*/
+/**
+* Mark the current render as requiring dynamic (uncached) rendering.
+* Called by connection(), cookies(), headers(), and noStore().
+*/
+function markDynamicUsage() {
+	const state = getHeadersShimState();
+	if (state.headersContext?.forceStatic) return;
+	state.dynamicUsageDetected = true;
+	const latches = [ensureRenderDynamicLatch(state)];
+	forEachConnectionProbeTarget(state, (target) => {
+		target.dynamicUsageDetected = true;
+		latches.push(ensureRenderDynamicLatch(target));
+	});
+	for (const latch of latches) latchRenderDynamic(latch);
+}
+function latchRenderDynamic(latch) {
+	if (latch.dynamic) return;
+	latch.dynamic = true;
+	const listeners = [...latch.listeners];
+	latch.listeners.clear();
+	for (const listener of listeners) try {
+		listener();
+	} catch (error) {
+		console.error(error);
+	}
+}
+/** Whether the current render has used a dynamic API at any point so far. */
+function isRenderDynamicLatched() {
+	return ensureRenderDynamicLatch(getHeadersShimState()).dynamic;
+}
+/**
+* Call `listener` once when the current render first uses a dynamic API.
+* Returns an unsubscribe function. The listener never runs if the render is
+* already latched; check `isRenderDynamicLatched()` first.
+*/
+function onRenderDynamicLatched(listener) {
+	const latch = ensureRenderDynamicLatch(getHeadersShimState());
+	if (latch.dynamic) return () => {};
+	latch.listeners.add(listener);
+	return () => {
+		latch.listeners.delete(listener);
+	};
+}
+function forEachConnectionProbeTarget(state, visit) {
+	let target = state.connectionProbe?.dynamicUsageTarget ?? null;
+	const seen = /* @__PURE__ */ new Set([state]);
+	while (target && !seen.has(target)) {
+		seen.add(target);
+		visit(target);
+		target = target.connectionProbe?.dynamicUsageTarget ?? null;
+	}
+}
+function propagateInvalidDynamicUsageError(state, error) {
+	forEachConnectionProbeTarget(state, (target) => {
+		if (target.invalidDynamicUsageError == null) target.invalidDynamicUsageError = error;
+	});
+}
+function markRenderRequestApiUsage(kind) {
+	getHeadersShimState().renderRequestApiUsage.add(kind);
+}
+function throwIfStaticGenerationAccessError() {
+	const accessError = getHeadersShimState().headersContext?.accessError;
+	if (accessError) throw accessError;
+}
+/** Symbol used by cache-runtime.ts to store the "use cache" ALS on globalThis */
+const _USE_CACHE_ALS_KEY = Symbol.for("vinext.cacheRuntime.contextAls");
+/** Symbol used by cache.ts to store the unstable_cache ALS on globalThis */
+const _UNSTABLE_CACHE_ALS_KEY = Symbol.for("vinext.unstableCache.als");
+function _getGlobalCacheScopeStore(key) {
+	const value = Reflect.get(globalThis, key);
+	if (!value || typeof value !== "object") return null;
+	const getStore = Reflect.get(value, "getStore");
+	if (typeof getStore !== "function") return null;
+	return getStore.call(value);
+}
+function _getUseCacheGuardContext() {
+	const store = _getGlobalCacheScopeStore(_USE_CACHE_ALS_KEY);
+	if (!store || typeof store !== "object") return null;
+	return store;
+}
+function _isInsidePublicUseCache() {
+	const ctx = _getUseCacheGuardContext();
+	return ctx !== null && ctx.variant !== "private";
+}
+function _isInsideUnstableCache() {
+	return _getGlobalCacheScopeStore(_UNSTABLE_CACHE_ALS_KEY) === true;
+}
+/** Whether work is executing inside a cache boundary that owns its reuse. */
+function isInsideAnyCacheScope() {
+	return _getUseCacheGuardContext() !== null || _isInsideUnstableCache();
+}
+/**
+* Throw if the current execution is inside a "use cache" or unstable_cache()
+* scope. Called by dynamic request APIs (headers, cookies, connection) to
+* prevent request-specific data from being frozen into cached results.
+*
+* @param apiName - The name of the API being called (e.g. "connection()")
+*/
+function throwIfInsideCacheScope(apiName) {
+	if (_isInsidePublicUseCache()) {
+		const error = /* @__PURE__ */ new Error(`\`${apiName}\` cannot be called inside "use cache". If you need this data inside a cached function, call \`${apiName}\` outside and pass the required data as an argument.`);
+		try {
+			const cacheCtx = _getUseCacheGuardContext();
+			if (cacheCtx) cacheCtx.invalidDynamicUsageError = error;
+			const ctx = getRequestContext();
+			if (ctx) ctx.invalidDynamicUsageError = error;
+			propagateInvalidDynamicUsageError(getHeadersShimState(), error);
+		} catch {}
+		throw error;
+	}
+	if (_isInsideUnstableCache()) {
+		const error = /* @__PURE__ */ new Error(`\`${apiName}\` cannot be called inside a function cached with \`unstable_cache()\`. If you need this data inside a cached function, call \`${apiName}\` outside and pass the required data as an argument.`);
+		try {
+			const ctx = getRequestContext();
+			if (ctx) ctx.invalidDynamicUsageError = error;
+			propagateInvalidDynamicUsageError(getHeadersShimState(), error);
+		} catch {}
+		throw error;
+	}
+}
+function getHeadersAccessPhase() {
+	return getHeadersShimState().phase;
+}
+//#endregion
+export { createRenderDynamicLatch, getHeadersAccessPhase, getHeadersShimState, headersShimAls, isInsideAnyCacheScope, isRenderDynamicLatched, markDynamicUsage, markRenderRequestApiUsage, onRenderDynamicLatched, throwIfInsideCacheScope, throwIfStaticGenerationAccessError };

package/dist/shims/metadata.js

@@ -1,6 +1,6 @@
 import { isAbsoluteOrProtocolRelativeUrl } from "./url-utils.js";
+import { withUseCacheLayoutMarker, withUseCachePageMarker } from "./internal/app-page-props-cache-key.js";
 import { makeThenableParams } from "./thenable-params.js";
-import { withUseCachePageMarker } from "./internal/app-page-props-cache-key.js";
 import React from "react";
 import { Fragment as Fragment$1, jsx } from "react/jsx-runtime";
 //#region src/shims/metadata.tsx
@@ -19,7 +19,7 @@ const USE_CACHE_ACCEPTS_SECOND_ARGUMENT_SYMBOL = Symbol.for("vinext.useCacheAcce
 async function resolveModuleViewport(mod, params = {}, searchParams, parent = Promise.resolve(mergeViewport([])), searchParamsObserver) {
 	if (typeof mod.generateViewport === "function") {
 		const asyncParams = makeThenableParams(params);
-		const props = searchParams === void 0 ? { params: asyncParams } : withUseCachePageMarker(mod.generateViewport, {
+		const props = searchParams === void 0 ? withUseCacheLayoutMarker(mod.generateViewport, { params: asyncParams }) : withUseCachePageMarker(mod.generateViewport, {
 			params: asyncParams,
 			searchParams: makeThenableParams(searchParams, searchParamsObserver)
 		});
@@ -268,7 +268,7 @@ async function resolveModuleMetadata(mod, params = {}, searchParams, parent = Pr
 	if (typeof mod.generateMetadata === "function") {
 		const generateMetadata = mod.generateMetadata;
 		const asyncParams = makeThenableParams(params);
-		const props = searchParams === void 0 ? { params: asyncParams } : withUseCachePageMarker(generateMetadata, {
+		const props = searchParams === void 0 ? withUseCacheLayoutMarker(generateMetadata, { params: asyncParams }) : withUseCachePageMarker(generateMetadata, {
 			params: asyncParams,
 			searchParams: makeThenableParams(searchParams, searchParamsObserver)
 		});

package/dist/shims/navigation-errors.d.ts

@@ -12,6 +12,12 @@ export declare enum RedirectType {
   push = "push",
   replace = "replace"
 }
+/**
+ * Whether `error` was thrown by redirect(), notFound() or another navigation
+ * function in the render that caught it, rather than decoded from an RSC
+ * render's digest.
+ */
+export declare function isThrownNavigationError(error: unknown): boolean;
 /**
  * The omitted redirect type is resolved by the catch site: push for Server
  * Actions and replace for ordinary SSR/RSC rendering.

package/dist/shims/navigation-errors.js

@@ -25,14 +25,24 @@ let RedirectType = /* @__PURE__ */ function(RedirectType) {
 	RedirectType["replace"] = "replace";
 	return RedirectType;
 }({});
+const THROWN_NAVIGATION_ERROR_MARKER = Symbol.for("vinext.navigationError.thrown");
 var VinextNavigationError = class extends Error {
 	digest;
+	[THROWN_NAVIGATION_ERROR_MARKER] = true;
 	constructor(message, digest) {
 		super(message);
 		this.digest = digest;
 	}
 };
 /**
+* Whether `error` was thrown by redirect(), notFound() or another navigation
+* function in the render that caught it, rather than decoded from an RSC
+* render's digest.
+*/
+function isThrownNavigationError(error) {
+	return typeof error === "object" && error !== null && Reflect.get(error, THROWN_NAVIGATION_ERROR_MARKER) === true;
+}
+/**
 * The omitted redirect type is resolved by the catch site: push for Server
 * Actions and replace for ordinary SSR/RSC rendering.
 */
@@ -103,4 +113,4 @@ function unstable_rethrow(error) {
 	if (error instanceof Error && "cause" in error) unstable_rethrow(error.cause);
 }
 //#endregion
-export { BailoutToCSRError, DynamicServerError, HTTP_ERROR_FALLBACK_ERROR_CODE, RedirectType, decodeRedirectError, forbidden, getAccessFallbackHTTPStatus, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, notFound, permanentRedirect, redirect, unauthorized, unstable_rethrow };
+export { BailoutToCSRError, DynamicServerError, HTTP_ERROR_FALLBACK_ERROR_CODE, RedirectType, decodeRedirectError, forbidden, getAccessFallbackHTTPStatus, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, isThrownNavigationError, notFound, permanentRedirect, redirect, unauthorized, unstable_rethrow };

package/dist/shims/navigation.d.ts

@@ -49,6 +49,13 @@ export type CachedRscResponse = {
   mountedSlotsHeader?: string | null;
   paramsHeader: string | null;
   preparedElements?: AppElements;
+  /**
+   * Streamed `redirect()` side-channel headers. A replayed snapshot must keep
+   * them so the navigation follows the redirect instead of decoding the
+   * redirect payload as a page.
+   */
+  redirectHeader?: string;
+  redirectTypeHeader?: string;
   renderedPathAndSearch: string | null;
   serverStaleTime?: ServerStaleTime;
   url: string;

package/dist/shims/navigation.js

@@ -2,27 +2,27 @@ import { isBotUserAgent } from "../utils/html-limited-bots.js";
 import { isExternalUrl } from "../utils/external-url.js";
 import { stripBasePath } from "../utils/base-path.js";
 import { NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_RENDER_MODE_HEADER } from "../server/app-rsc-vary.js";
-import { NEXT_ROUTER_STALE_TIME_HEADER, VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_PARAMS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_RSC_COMPLETION_METADATA_HEADER, VINEXT_STALE_TIME_PENDING_HEADER } from "../server/headers.js";
+import { NEXT_ROUTER_STALE_TIME_HEADER, VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_PARAMS_HEADER, VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, VINEXT_RSC_COMPLETION_METADATA_HEADER, VINEXT_RSC_REDIRECT_HEADER, VINEXT_RSC_REDIRECT_TYPE_HEADER, VINEXT_STALE_TIME_PENDING_HEADER } from "../server/headers.js";
 import { assertSafeNavigationUrl } from "./url-safety.js";
 import { APP_RSC_RENDER_MODE_PREFETCH_DYNAMIC_SHELL, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL } from "../server/app-rsc-render-mode.js";
-import { AppElementsWire } from "../server/app-elements-wire.js";
-import "../server/app-elements.js";
 import { getPprFallbackShellState, markPprFallbackShellDynamicBoundary } from "./ppr-fallback-shell.js";
 import { AppRouterContext } from "./internal/app-router-context.js";
 import { resolveDirectHybridClientRouteOwner } from "./internal/hybrid-client-route-owner-direct.js";
 import { isHashOnlyBrowserUrlChange, toCanonicalBrowserNavigationHref, toSameOriginAppPath, withBasePath } from "./url-utils.js";
 import { retryScrollTo, scrollToHashTarget, scrollToHashTargetOnNextFrame } from "./hash-scroll.js";
+import { AppElementsWire } from "../server/app-elements-wire.js";
+import "../server/app-elements.js";
 import { GLOBAL_ACCESSORS_KEY, ServerInsertedHTMLContext, _registerStateAccessors, clearClientHydrationContext, clearServerInsertedHTML, flushServerInsertedHTML, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getLayoutSegmentContext, getNavigationContext, registerServerInsertedHTMLCallback, renderServerInsertedHTML, setNavigationContext } from "./navigation-context-state.js";
 import { BailoutToCSRError, DynamicServerError, HTTP_ERROR_FALLBACK_ERROR_CODE, RedirectType, decodeRedirectError, forbidden, getAccessFallbackHTTPStatus, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, notFound, permanentRedirect, redirect, unauthorized, unstable_rethrow } from "./navigation-errors.js";
 import { clearAppNavigationFailureTarget, stageAppNavigationFailureTarget } from "../client/app-nav-failure-handler.js";
 import { beginAppRouterScrollIntent, clearAppRouterScrollIntent, consumeAppRouterScrollIntent, getPendingAppRouterScrollIntent, isLatestAppRouterScrollIntent } from "./app-router-scroll-state.js";
 import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, createRscRequestHeaders, createRscRequestUrl, stripRscCacheBustingSearchParam, stripRscSuffix } from "../server/app-rsc-cache-busting.js";
-import { getNavigationRuntime, hasAppNavigationRuntime } from "../client/navigation-runtime.js";
 import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.js";
+import { getNavigationRuntime, hasAppNavigationRuntime } from "../client/navigation-runtime.js";
 import { UnrecognizedActionError, unstable_isUnrecognizedActionError } from "./unrecognized-action-error.js";
 import { PUBLIC_INITIAL_BFCACHE_ID } from "../server/app-bfcache-id.js";
-import { createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, isAppOwnedHistoryState } from "../server/app-history-state.js";
 import { resolveManifestNavigationInterceptionContext } from "../server/app-browser-interception-context.js";
+import { createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata, isAppOwnedHistoryState } from "../server/app-history-state.js";
 import { hasPendingAppRouterPageRedirect } from "../server/app-browser-mpa-navigation.js";
 import { extractRscCompletionMetadata } from "../server/rsc-completion-metadata.js";
 import { navigationPlanner } from "../server/navigation-planner.js";
@@ -662,6 +662,8 @@ function createCachedRscResponseSnapshot(response, buffer, responseUrl = null) {
 		kind: "resolved",
 		seconds: extracted.metadata.serverStaleTimeSeconds
 	} : parsedServerStaleTime;
+	const redirectHeader = response.headers.get(VINEXT_RSC_REDIRECT_HEADER);
+	const redirectTypeHeader = response.headers.get(VINEXT_RSC_REDIRECT_TYPE_HEADER);
 	return {
 		compatibilityIdHeader: response.headers.get(VINEXT_RSC_COMPATIBILITY_ID_HEADER),
 		buffer: extracted.buffer,
@@ -670,6 +672,8 @@ function createCachedRscResponseSnapshot(response, buffer, responseUrl = null) {
 		...dynamicStaleTimeSeconds !== void 0 ? { dynamicStaleTimeSeconds } : {},
 		mountedSlotsHeader: response.headers.get(VINEXT_MOUNTED_SLOTS_HEADER),
 		paramsHeader: response.headers.get(VINEXT_PARAMS_HEADER),
+		...redirectHeader === null ? {} : { redirectHeader },
+		...redirectTypeHeader === null ? {} : { redirectTypeHeader },
 		renderedPathAndSearch: parseRenderedPathAndSearchHeader(response.headers.get(VINEXT_RENDERED_PATH_AND_SEARCH_HEADER)),
 		...serverStaleTime === void 0 ? {} : { serverStaleTime },
 		url: responseUrl ?? response.url
@@ -739,6 +743,8 @@ function restoreRscResponse(cached, copy = true) {
 	if (cached.serverStaleTime?.kind === "pending") headers.set(VINEXT_STALE_TIME_PENDING_HEADER, "1");
 	else if (cached.serverStaleTime !== void 0) headers.set(NEXT_ROUTER_STALE_TIME_HEADER, String(cached.serverStaleTime.seconds));
 	if (cached.paramsHeader != null) headers.set(VINEXT_PARAMS_HEADER, cached.paramsHeader);
+	if (cached.redirectHeader !== void 0) headers.set(VINEXT_RSC_REDIRECT_HEADER, cached.redirectHeader);
+	if (cached.redirectTypeHeader !== void 0) headers.set(VINEXT_RSC_REDIRECT_TYPE_HEADER, cached.redirectTypeHeader);
 	if (cached.renderedPathAndSearch != null) headers.set(VINEXT_RENDERED_PATH_AND_SEARCH_HEADER, encodeURIComponent(cached.renderedPathAndSearch));
 	const response = new Response(copy ? cached.buffer.slice(0) : cached.buffer, {
 		status: 200,
@@ -826,7 +832,7 @@ function prefetchRscResponse(rscUrl, fetchPromise, interceptionContext = null, m
 			entry.size = snapshot.buffer.byteLength;
 			adjustPrefetchCacheByteSize(cache, entry.size - previousSize);
 			entry.expiresAt = resolvePrefetchedRscResponseExpiresAt(entry.timestamp, entry.snapshot, behavior.fallbackTtlMs ?? PREFETCH_CACHE_TTL, behavior.searchAgnosticShell === true ? "ignore" : behavior.dynamicStaleTime ?? (behavior.optimisticRouteShell === true ? "ignore" : "verbatim"));
-			if (behavior.prepareSnapshot) try {
+			if (behavior.prepareSnapshot && snapshot.redirectHeader === void 0) try {
 				const preparedElements = await behavior.prepareSnapshot(snapshot);
 				if (cache.get(cacheKey) !== entry) return;
 				entry.preparedElements = preparedElements;
@@ -1781,6 +1787,7 @@ if (!isServer) {
 			}
 		});
 		window.history.pushState = function patchedPushState(data, unused, url) {
+			getNavigationRuntime()?.functions.flushCommittingNavigationUrl?.();
 			if (isAppOwnedHistoryState(data)) {
 				const previousHistoryState = window.history.state;
 				state.originalPushState.call(window.history, data, unused, url);
@@ -1792,10 +1799,12 @@ if (!isServer) {
 			getNavigationRuntime()?.functions.claimCurrentHistoryTreeSnapshot?.("push", previousHistoryState);
 			if (state.suppressUrlNotifyCount === 0) {
 				resetStaleLinkStatus();
+				if (url) getNavigationRuntime()?.functions.discardPendingNavigation?.();
 				commitClientNavigationState();
 			}
 		};
 		window.history.replaceState = function patchedReplaceState(data, unused, url) {
+			getNavigationRuntime()?.functions.flushCommittingNavigationUrl?.();
 			if (isAppOwnedHistoryState(data)) {
 				const previousHistoryState = window.history.state;
 				state.originalReplaceState.call(window.history, data, unused, url);
@@ -1807,6 +1816,7 @@ if (!isServer) {
 			getNavigationRuntime()?.functions.claimCurrentHistoryTreeSnapshot?.("replace", previousHistoryState);
 			if (state.suppressUrlNotifyCount === 0) {
 				resetStaleLinkStatus();
+				if (url) getNavigationRuntime()?.functions.discardPendingNavigation?.();
 				commitClientNavigationState();
 			}
 		};

package/dist/shims/request-context.d.ts

@@ -44,6 +44,15 @@ export type ExecutionContextLike = {
   isInternalPagesRevalidation?: boolean;
   /** Marks a build-secret-authorized Worker request that may run prerender discovery hooks. */
   isPrerenderPathDiscovery?: boolean;
+  /**
+   * Installed only by the prerender server: records the page's special error
+   * that escaped the shell, with the headers to store, for the build.
+   */
+  recordPrerenderSpecialError?: (marker: PrerenderSpecialErrorMarker) => void;
+};
+export type PrerenderSpecialErrorMarker = {
+  headers: Record<string, string>;
+  status: number;
 };
 /**
  * Run `fn` with the given `ExecutionContext` available via

package/dist/shims/request-state-types.d.ts

@@ -4,7 +4,8 @@ import "./navigation.js";
 import { CacheLifeConfig, CacheState } from "./cache-request-state.js";
 import { RootParamsState } from "./root-params.js";
 import { FetchCacheState } from "./fetch-cache.js";
-import { HeadersAccessPhase, HeadersContext, VinextHeadersShimState } from "./headers.js";
+import { HeadersAccessPhase, VinextHeadersShimState } from "./internal/headers-state.js";
+import { HeadersContext } from "./headers.js";
 import { RouterState, SSRContext } from "./router-state.js";
 import { PrivateCacheState } from "./cache-runtime.js";
 import { HeadState } from "./head-state.js";

package/dist/shims/root-params.js

@@ -1,6 +1,6 @@
 import { getOrCreateAls } from "./internal/als-registry.js";
 import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
-import { _recordUseCacheRootParamRead } from "./cache-request-state.js";
+import { _recordUseCacheRootParamRead } from "./internal/cache-context-accessor.js";
 //#region src/shims/root-params.ts
 function createRootParamsUsageError(message) {
 	return new Error(message);

package/dist/shims/server.js

@@ -48,15 +48,65 @@ function _throwIfInsideCacheScope(apiName) {
 		throw error;
 	}
 }
+/**
+* Workers can hand a GET/HEAD a non-null body (e.g. a GET sent with
+* Content-Length). Next.js nulls GET/HEAD bodies before user code runs, so a
+* NextRequest never carries one either.
+*/
+function hasGetOrHeadBody(request) {
+	return (request.method === "GET" || request.method === "HEAD") && request.body !== null;
+}
+/**
+* The Request constructor rejects such a body when it reads a Request init as
+* a dictionary, as it does for the route handler's tracking Proxy, so rebuild
+* the init without it. Every other standard field, plus workerd's `cf` and
+* `fetcher`, is copied so a framed GET builds the same Request as an unframed
+* one. (`duplex` only applies to a body.)
+*/
+function requestInitFromRequest(request) {
+	if (!hasGetOrHeadBody(request)) return request;
+	const cf = Reflect.get(request, "cf");
+	const fetcher = Reflect.get(request, "fetcher");
+	return {
+		method: request.method,
+		headers: request.headers,
+		body: null,
+		cache: request.cache,
+		credentials: request.credentials,
+		integrity: request.integrity,
+		keepalive: request.keepalive,
+		mode: request.mode,
+		redirect: request.redirect,
+		referrer: request.referrer,
+		referrerPolicy: request.referrerPolicy,
+		signal: request.signal,
+		...cf !== void 0 ? { cf } : {},
+		...fetcher !== void 0 ? { fetcher } : {}
+	};
+}
+/**
+* A Request input passes its body on unless the init replaces it, so drop a
+* GET/HEAD input's body when the init keeps the input's method and body. This
+* covers the requests vinext hands to middleware, route handlers and edge API
+* routes.
+*/
+function initWithoutInputBody(input, init) {
+	if (init instanceof Request || init.method !== void 0 || init.body !== void 0 || !hasGetOrHeadBody(input)) return init;
+	return {
+		...init,
+		body: null
+	};
+}
 var NextRequest = class extends Request {
 	_nextUrl;
 	_url;
 	_cookies;
 	constructor(input, init) {
 		validateURL(typeof input !== "string" && "url" in input ? input.url : String(input));
-		const { nextConfig: _nextConfig, ...requestInit } = init ?? {};
+		const { nextConfig: _nextConfig, ...plainInit } = init ?? {};
+		const requestInit = init instanceof Request ? requestInitFromRequest(init) : plainInit;
 		if (input instanceof Request) {
-			super(input, requestInit);
+			super(input, initWithoutInputBody(input, requestInit));
 			const cfDescriptor = Reflect.getOwnPropertyDescriptor(input, "cf");
 			if (cfDescriptor) Object.defineProperty(this, "cf", cfDescriptor);
 			else {

package/dist/shims/thenable-params.d.ts

@@ -5,5 +5,9 @@ export type ThenableParamsObserver = Readonly<{
   observeParamAccess: (keys: readonly string[]) => void;
   observeReactPromiseStatus?: boolean;
 }>;
+/** Serialize backing values without reading a framework fallback-key proxy. */
+export declare function getFallbackParamsSnapshot(value: unknown): Promise<Record<string, unknown>> | undefined;
+/** Reattach only framework metadata; argument values always come from the decoder. */
+export declare function restoreThenableParams<T extends Record<string, unknown>>(decoded: T, original: unknown): ThenableParams<T>;
 export declare function makeThenableParams<T extends Record<string, unknown>>(obj: T, observer?: ThenableParamsObserver): ThenableParams<T>;
 //#endregion

package/dist/shims/thenable-params.js

@@ -4,6 +4,20 @@ import { isOwnPropertyCheck, isWellKnownProperty } from "./internal/thenable-wel
 function hasParamProperty(obj, prop) {
 	return Object.prototype.hasOwnProperty.call(obj, prop);
 }
+const paramsState = /* @__PURE__ */ new WeakMap();
+function getParamsState(value) {
+	return value !== null && typeof value === "object" ? paramsState.get(value) : void 0;
+}
+/** Serialize backing values without reading a framework fallback-key proxy. */
+function getFallbackParamsSnapshot(value) {
+	const state = getParamsState(value);
+	return state?.fallbackShellState ? Promise.resolve(state.plain) : void 0;
+}
+/** Reattach only framework metadata; argument values always come from the decoder. */
+function restoreThenableParams(decoded, original) {
+	const state = getParamsState(original);
+	return createThenableParams(decoded, state?.observer, state?.fallbackShellState ?? null);
+}
 function observeParamKeys(observer, keys) {
 	if (observer) observer.observeParamAccess(keys);
 }
@@ -81,8 +95,10 @@ function createThenableParamsProxy(promise, handler) {
 	return new Proxy(promise, handler);
 }
 function makeThenableParams(obj, observer) {
+	return createThenableParams(obj, observer, getPprFallbackShellState());
+}
+function createThenableParams(obj, observer, fallbackShellState) {
 	const plain = { ...obj };
-	const fallbackShellState = getPprFallbackShellState();
 	const fallbackParamNames = fallbackShellState && Object.keys(plain).some((key) => fallbackShellState.fallbackParamNames.has(key)) ? fallbackShellState.fallbackParamNames : null;
 	let fallbackShellPromise = null;
 	let fallbackShellPromiseController = null;
@@ -98,7 +114,7 @@ function makeThenableParams(obj, observer) {
 	function isFallbackParam(prop) {
 		return typeof prop === "string" && (fallbackParamNames?.has(prop) ?? false);
 	}
-	return createThenableParamsProxy(promise, {
+	const params = createThenableParamsProxy(promise, {
 		get(target, prop, receiver) {
 			if (isPromiseContinuation(prop)) {
 				const value = Reflect.get(target, prop, receiver);
@@ -150,6 +166,12 @@ function makeThenableParams(obj, observer) {
 			return Reflect.ownKeys(plain).filter((prop) => !isWellKnownProperty(prop));
 		}
 	});
+	paramsState.set(params, {
+		plain,
+		observer,
+		fallbackShellState: fallbackParamNames ? fallbackShellState : null
+	});
+	return params;
 }
 //#endregion
-export { makeThenableParams };
+export { getFallbackParamsSnapshot, makeThenableParams, restoreThenableParams };

package/dist/shims/unified-request-context.d.ts

@@ -2,7 +2,7 @@ import { ExecutionContextLike } from "./request-context.js";
 import { CacheState } from "./cache-request-state.js";
 import { RootParamsState } from "./root-params.js";
 import { FetchCacheState } from "./fetch-cache.js";
-import { VinextHeadersShimState } from "./headers.js";
+import { VinextHeadersShimState } from "./internal/headers-state.js";
 import { RouterState } from "./router-state.js";
 import { markFullyBufferedBody, preserveFullyBufferedBodyMetadata } from "../server/fully-buffered-response.js";
 import { PrivateCacheState } from "./cache-runtime.js";

package/dist/shims/unified-request-context.js

@@ -17,6 +17,7 @@ function createRequestContext(opts) {
 	return {
 		headersContext: null,
 		actionRevalidationKind: 0,
+		cacheLifeSink: null,
 		pendingRevalidatedTags: /* @__PURE__ */ new Set(),
 		pendingRevalidations: /* @__PURE__ */ new Set(),
 		dynamicUsageDetected: false,

package/dist/utils/encode-cache-tag.d.ts

@@ -25,5 +25,6 @@
  * (introduced in vercel/next.js#93601).
  */
 export declare function encodeCacheTag(tag: string): string;
+/** Validate raw public tag types and lengths before header encoding. */
 export declare function encodeCacheTags(tags: readonly string[]): string[];
 //#endregion

package/dist/utils/encode-cache-tag.js

@@ -26,11 +26,21 @@
 */
 const OUT_OF_CLASS_CHAR = /[^\t\x20-\x7e]/;
 const OUT_OF_CLASS_RUN = /[^\t\x20-\x7e]+/g;
+const MAX_TAG_LENGTH = 256;
 function encodeCacheTag(tag) {
 	return OUT_OF_CLASS_CHAR.test(tag) ? tag.replace(OUT_OF_CLASS_RUN, (run) => encodeURIComponent(run)) : tag;
 }
+/** Validate raw public tag types and lengths before header encoding. */
 function encodeCacheTags(tags) {
-	return tags.map(encodeCacheTag);
+	const encoded = [];
+	for (const tag of tags) {
+		if (typeof tag !== "string" || tag.length > MAX_TAG_LENGTH) {
+			console.warn(`[vinext] Cache tags must be strings of at most ${MAX_TAG_LENGTH} characters; invalid tag ignored.`);
+			continue;
+		}
+		encoded.push(encodeCacheTag(tag));
+	}
+	return encoded;
 }
 //#endregion
 export { encodeCacheTag, encodeCacheTags };

package/dist/utils/mdx-scan.d.ts

@@ -5,6 +5,11 @@ export declare const mdxScanCache: Map<string, boolean>;
  * Check if the project has .mdx files in app/ or pages/ directories.
  */
 export declare function hasMdxFiles(root: string, appDir: string | null, pagesDir: string | null): boolean;
+/**
+ * Whether page extensions discover MDX sources, including compound extensions
+ * such as `page.mdx`.
+ */
+export declare function pageExtensionsIncludeMdx(pageExtensions: readonly string[]): boolean;
 /**
  * Load a reader that keeps only the ESM of an MDX module, so the JavaScript
  * export helpers can read it. It takes the ESM nodes from the MDX parser that

package/dist/utils/mdx-scan.js

@@ -33,6 +33,13 @@ function scanDirForMdx(dir) {
 	return false;
 }
 /**
+* Whether page extensions discover MDX sources, including compound extensions
+* such as `page.mdx`.
+*/
+function pageExtensionsIncludeMdx(pageExtensions) {
+	return pageExtensions.some((extension) => extension.toLowerCase().split(".").at(-1) === "mdx");
+}
+/**
 * Load a reader that keeps only the ESM of an MDX module, so the JavaScript
 * export helpers can read it. It takes the ESM nodes from the MDX parser that
 * `@mdx-js/rollup` compiles with, resolved beside the plugin vinext
@@ -57,4 +64,4 @@ async function loadMdxEsmReader(root) {
 	return (source) => processor.parse(source).children.flatMap((node) => node.type === "mdxjsEsm" && typeof node.value === "string" ? [node.value] : []).join("\n\n");
 }
 //#endregion
-export { hasMdxFiles, loadMdxEsmReader, mdxScanCache };
+export { hasMdxFiles, loadMdxEsmReader, mdxScanCache, pageExtensionsIncludeMdx };

package/dist/utils/regex-safety.d.ts

@@ -1,7 +1,17 @@
 //#region src/utils/regex-safety.d.ts
 export type RegexSafetyIssue = "nested repetition" | "ambiguous alternatives under repetition" | "ambiguous sequence expansion" | "overlapping sequential repetition" | "analysis budget exceeded";
+/**
+ * Whether a RegExp source declares a named group, which turns `\k<name>` into
+ * a backreference. Escaped characters and character classes cannot open one.
+ */
+export declare function mayHaveNamedGroups(pattern: string): boolean;
+/**
+ * `namedGroups` must describe the whole compiled RegExp when `pattern` is only
+ * a fragment of it. It defaults to scanning `pattern` itself.
+ */
 export declare function analyzeRegexSafety(pattern: string, options?: {
   ignoreCase?: boolean;
+  namedGroups?: boolean;
 }): RegexSafetyIssue | null;
 export declare function regexAtomsMayOverlap(left: string, right: string, ignoreCase?: boolean): boolean;
 //#endregion