vinext 1.0.1 → 1.1.0

package/dist/shims/error-boundary.d.ts

@@ -29,6 +29,11 @@ type CapturedError = {
 type RedirectBoundaryState = {
   redirect: string | null;
   redirectType: "push" | "replace" | null;
+  previousResetKey: string | null;
+};
+type RedirectBoundaryProps = {
+  children?: React.ReactNode;
+  resetKey?: string | null;
 };
 type ErrorBoundaryInnerProps = {
   isImplicitRootErrorBoundary?: boolean;
@@ -39,18 +44,13 @@ export type ErrorBoundaryState = {
   previousPathname: string | null;
   previousResetKey: string | null;
 };
-export declare class RedirectErrorBoundary extends React.Component<{
-  children?: React.ReactNode;
-}, RedirectBoundaryState> {
-  constructor(props: {
-    children?: React.ReactNode;
-  });
-  static getDerivedStateFromError(error: unknown): RedirectBoundaryState;
+export declare class RedirectErrorBoundary extends React.Component<RedirectBoundaryProps, RedirectBoundaryState> {
+  constructor(props: RedirectBoundaryProps);
+  static getDerivedStateFromProps(props: RedirectBoundaryProps, state: RedirectBoundaryState): RedirectBoundaryState | null;
+  static getDerivedStateFromError(error: unknown): Omit<RedirectBoundaryState, "previousResetKey">;
   render(): string | number | bigint | boolean | React.JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | Iterable<React.ReactNode> | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | React.ReactPortal | null | undefined> | null | undefined;
 }
-export declare function RedirectBoundary({ children }: {
-  children?: React.ReactNode;
-}): React.JSX.Element;
+export declare function RedirectBoundary({ children, resetKey }: RedirectBoundaryProps): React.JSX.Element;
 /**
  * Generic ErrorBoundary used to wrap route segments with error.tsx.
  * This must be a client component since error boundaries use

package/dist/shims/error-boundary.js

@@ -2,7 +2,7 @@
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
 import { decodeRedirectError, isRedirectError } from "./navigation-errors.js";
 import "./navigation-server.js";
-import { useErrorBoundaryPathname, useErrorBoundaryRouter } from "./error-boundary-navigation.js";
+import { isRedirectToCurrentUrl, useErrorBoundaryPathname, useErrorBoundaryRouter } from "./error-boundary-navigation.js";
 import DefaultGlobalError from "./default-global-error.js";
 import { handleAppNavigationFailure } from "../client/app-nav-failure-handler.js";
 import { VINEXT_DEV_ERROR_RECOVERY_EVENT } from "../utils/dev-error-recovery-event.js";
@@ -43,9 +43,13 @@ function removeDevErrorRecoveryListener(listener) {
 	if (typeof window === "undefined") return;
 	window.removeEventListener(VINEXT_DEV_ERROR_RECOVERY_EVENT, listener);
 }
-function HandleRedirect({ redirect, redirectType, reset }) {
+function HandleRedirect({ redirect, redirectType, reset, stopsSelfRedirect }) {
 	const router = useErrorBoundaryRouter();
 	React.useEffect(() => {
+		if (stopsSelfRedirect && isRedirectToCurrentUrl(redirect)) {
+			console.error("[vinext] redirect() resolved to the current URL — not following it, to prevent an infinite loop.");
+			return;
+		}
 		React.startTransition(() => {
 			if (redirectType === "push") router.push(redirect);
 			else router.replace(redirect);
@@ -55,7 +59,8 @@ function HandleRedirect({ redirect, redirectType, reset }) {
 		redirect,
 		redirectType,
 		reset,
-		router
+		router,
+		stopsSelfRedirect
 	]);
 	return null;
 }
@@ -64,7 +69,17 @@ var RedirectErrorBoundary = class extends React.Component {
 		super(props);
 		this.state = {
 			redirect: null,
-			redirectType: null
+			redirectType: null,
+			previousResetKey: normalizeBoundaryResetKey(props.resetKey)
+		};
+	}
+	static getDerivedStateFromProps(props, state) {
+		const resetKey = normalizeBoundaryResetKey(props.resetKey);
+		if (resetKey === state.previousResetKey) return null;
+		return {
+			redirect: null,
+			redirectType: null,
+			previousResetKey: resetKey
 		};
 	}
 	static getDerivedStateFromError(error) {
@@ -90,13 +105,17 @@ var RedirectErrorBoundary = class extends React.Component {
 			reset: () => this.setState({
 				redirect: null,
 				redirectType: null
-			})
+			}),
+			stopsSelfRedirect: this.props.resetKey !== void 0
 		});
 		return this.props.children;
 	}
 };
-function RedirectBoundary({ children }) {
-	return /* @__PURE__ */ jsx(RedirectErrorBoundary, { children });
+function RedirectBoundary({ children, resetKey }) {
+	return /* @__PURE__ */ jsx(RedirectErrorBoundary, {
+		resetKey,
+		children
+	});
 }
 /**
 * Generic ErrorBoundary used to wrap route segments with error.tsx.

package/dist/shims/fetch-cache.d.ts

@@ -103,6 +103,12 @@ export declare function setRefreshStaleFetchesInForeground(enabled: boolean): vo
  *   try { await render(); } finally { cleanup(); }
  */
 export declare function withFetchCache(): () => void;
+/**
+ * Run `fn` with the request's fetch settings but its own record of the tags and
+ * URLs its fetches touch, so work done on the request's behalf after the fact
+ * (a background regeneration) leaves the request's response untouched.
+ */
+export declare function runWithDetachedFetchObservations<T>(fn: () => Promise<T>): Promise<T>;
 /**
  * Run an async function with patched fetch caching enabled.
  * Uses `AsyncLocalStorage.run()` for proper per-request isolation

package/dist/shims/fetch-cache.js

@@ -834,6 +834,24 @@ function withFetchCache() {
 	};
 }
 /**
+* Run `fn` with the request's fetch settings but its own record of the tags and
+* URLs its fetches touch, so work done on the request's behalf after the fact
+* (a background regeneration) leaves the request's response untouched.
+*/
+function runWithDetachedFetchObservations(fn) {
+	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((uCtx) => {
+		uCtx.cacheableFetchUrls = /* @__PURE__ */ new Set();
+		uCtx.currentRequestTags = [];
+		uCtx.dynamicFetchUrls = /* @__PURE__ */ new Set();
+	}, fn);
+	return _als.run({
+		..._getState(),
+		cacheableFetchUrls: /* @__PURE__ */ new Set(),
+		currentRequestTags: [],
+		dynamicFetchUrls: /* @__PURE__ */ new Set()
+	}, fn);
+}
+/**
 * Run an async function with patched fetch caching enabled.
 * Uses `AsyncLocalStorage.run()` for proper per-request isolation
 * of collected fetch tags in concurrent server environments.
@@ -897,4 +915,4 @@ function getOriginalFetch() {
 	return originalFetch;
 }
 //#endregion
-export { _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getCurrentFetchSoftTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchRevalidate, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault, setRefreshStaleFetchesInForeground, withFetchCache };
+export { _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getCurrentFetchSoftTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithDetachedFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchRevalidate, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault, setRefreshStaleFetchesInForeground, withFetchCache };

package/dist/shims/form.js

@@ -4,9 +4,9 @@ import { VINEXT_MOUNTED_SLOTS_HEADER } from "../server/app-rsc-vary.js";
 import "../server/headers.js";
 import { assertSafeNavigationUrl } from "./url-safety.js";
 import { APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL } from "../server/app-rsc-render-mode.js";
+import { withBasePath } from "./url-utils.js";
 import { AppElementsWire } from "../server/app-elements-wire.js";
 import "../server/app-elements.js";
-import { withBasePath } from "./url-utils.js";
 import { createRscRequestHeaders, createRscRequestUrl } from "../server/app-rsc-cache-busting.js";
 import { hasAppNavigationRuntime } from "../client/navigation-runtime.js";
 import { getMountedSlotsHeader, getPrefetchInterceptionContext, getPrefetchedUrls, hasPrefetchCacheEntryForNavigation, navigateClientSide, prefetchRscResponse } from "./navigation.js";

package/dist/shims/headers.d.ts

@@ -1,4 +1,5 @@
 import { RenderRequestApiKind } from "../server/cache-proof.js";
+import { CacheLifeConfig } from "./cache-request-state.js";
 import { ConnectionProbeResult, HeadersAccessPhase, RenderDynamicLatch, VinextHeadersShimState, createRenderDynamicLatch, getHeadersAccessPhase, isInsideAnyCacheScope, isRenderDynamicLatched, markDynamicUsage, markRenderRequestApiUsage, onRenderDynamicLatched, throwIfInsideCacheScope, throwIfStaticGenerationAccessError } from "./internal/headers-state.js";
 import { ReadonlyRequestCookies } from "@vinext/types/next/upstream/dist/server/web/spec-extension/adapters/request-cookies";
 import { ResponseCookie } from "@vinext/types/next/upstream/dist/compiled/@edge-runtime/cookies/index";
@@ -27,6 +28,18 @@ export declare function runWithIsolatedDynamicUsage<T>(fn: () => T | Promise<T>)
   result: T;
   dynamicDetected: boolean;
 }>;
+/**
+ * Run a pre-render probe without letting its dynamic API usage classify the
+ * request. Next.js has no probe: only the render decides whether a page is
+ * dynamic, and the render runs the probed layouts and page again. Returns the
+ * probe's own usage and cacheLife for a caller whose probe response replaces
+ * the render.
+ */
+export declare function runWithDetachedDynamicUsage<T>(fn: () => T | Promise<T>): Promise<{
+  result: T;
+  dynamicDetected: boolean;
+  cacheLife: CacheLifeConfig | null;
+}>;
 export declare function runWithConnectionProbe<T>(fn: () => T | Promise<T>): Promise<ConnectionProbeResult<T>>;
 export declare function suspendConnectionProbe(): Promise<never> | null;
 export declare function peekRenderRequestApiUsage(): RenderRequestApiKind[];

package/dist/shims/headers.js

@@ -114,6 +114,49 @@ async function runWithIsolatedDynamicUsage(fn) {
 	};
 	return await headersShimAls.run(childState, () => runInChildState(childState));
 }
+/**
+* Run a pre-render probe without letting its dynamic API usage classify the
+* request. Next.js has no probe: only the render decides whether a page is
+* dynamic, and the render runs the probed layouts and page again. Returns the
+* probe's own usage and cacheLife for a caller whose probe response replaces
+* the render.
+*/
+async function runWithDetachedDynamicUsage(fn) {
+	const runInChildState = async (childState, cacheLifeSink) => {
+		return {
+			result: await fn(),
+			cacheLife: cacheLifeSink?.cacheLife ?? null,
+			dynamicDetected: childState.dynamicUsageDetected || childState.renderDynamicLatch.dynamic
+		};
+	};
+	if (isInsideUnifiedScope()) {
+		let childState = null;
+		const cacheLifeSink = { cacheLife: null };
+		return await runWithUnifiedStateMutation((context) => {
+			context.cacheLifeSink = cacheLifeSink;
+			context.dynamicUsageDetected = false;
+			context.renderDynamicLatch = createRenderDynamicLatch();
+			context.renderRequestApiUsage = /* @__PURE__ */ new Set();
+			context.requestCache = /* @__PURE__ */ new WeakMap();
+			context.cacheableFetchUrls = /* @__PURE__ */ new Set();
+			context.currentRequestTags = [];
+			context.dynamicFetchUrls = /* @__PURE__ */ new Set();
+			context.requestScopedCacheLife = null;
+			context.unstableCacheObservations = /* @__PURE__ */ new Map();
+			childState = context;
+		}, () => {
+			if (!childState) throw new Error("Dynamic usage scope was not initialized");
+			return runInChildState(childState, cacheLifeSink);
+		});
+	}
+	const childState = {
+		...getHeadersShimState(),
+		dynamicUsageDetected: false,
+		renderDynamicLatch: createRenderDynamicLatch(),
+		renderRequestApiUsage: /* @__PURE__ */ new Set()
+	};
+	return await headersShimAls.run(childState, () => runInChildState(childState, null));
+}
 async function runWithConnectionProbe(fn) {
 	const parentState = getHeadersShimState();
 	const parentInvalidDynamicUsageError = parentState.invalidDynamicUsageError;
@@ -129,8 +172,7 @@ async function runWithConnectionProbe(fn) {
 			if (probe.interrupted) return;
 			probe.interrupted = true;
 			interruptProbe();
-		},
-		pending: new Promise(() => {})
+		}
 	};
 	const runInChildState = async (childState) => {
 		try {
@@ -141,6 +183,7 @@ async function runWithConnectionProbe(fn) {
 			return await Promise.race([completed, interrupted]);
 		} finally {
 			probe.active = false;
+			interruptProbe();
 			childState.connectionProbe = parentState.connectionProbe ?? probe;
 			if (childState.dynamicUsageDetected) parentState.dynamicUsageDetected = true;
 			if (childState.invalidDynamicUsageError !== parentInvalidDynamicUsageError && parentState.invalidDynamicUsageError === parentInvalidDynamicUsageError) parentState.invalidDynamicUsageError = childState.invalidDynamicUsageError;
@@ -167,7 +210,7 @@ function suspendConnectionProbe() {
 	const probe = getHeadersShimState().connectionProbe;
 	if (!probe?.active) return null;
 	probe.interrupt();
-	return probe.pending;
+	return new Promise(() => {});
 }
 function peekRenderRequestApiUsage() {
 	return [...getHeadersShimState().renderRequestApiUsage].sort();
@@ -834,4 +877,4 @@ function serializeMutableCookie(cookie) {
 	});
 }
 //#endregion
-export { applyEffectiveRequestCookieHeader, applyMiddlewareRequestHeaders, consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage, cookies, createRenderDynamicLatch, draftMode, getActiveDraftModeState, getAndClearPendingCookies, getDraftModeCookieHeader, getEffectiveRequestCookieHeader, getHeadersAccessPhase, getHeadersContext, hasDraftModeCookieHeader, hasEffectiveRequestCookieChanges, headers, headersContextFromRequest, isDraftModeEnabled, isDraftModeRequest, isInsideAnyCacheScope, isRenderDynamicLatched, markDynamicUsage, markRenderRequestApiUsage, onRenderDynamicLatched, peekDynamicUsage, peekRenderRequestApiUsage, replaceHeadersContext, restoreDraftModeTransition, runWithConnectionProbe, runWithHeadersContext, runWithIsolatedDynamicUsage, setHeadersAccessPhase, setHeadersContext, suspendConnectionProbe, throwIfInsideCacheScope, throwIfStaticGenerationAccessError };
+export { applyEffectiveRequestCookieHeader, applyMiddlewareRequestHeaders, consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage, cookies, createRenderDynamicLatch, draftMode, getActiveDraftModeState, getAndClearPendingCookies, getDraftModeCookieHeader, getEffectiveRequestCookieHeader, getHeadersAccessPhase, getHeadersContext, hasDraftModeCookieHeader, hasEffectiveRequestCookieChanges, headers, headersContextFromRequest, isDraftModeEnabled, isDraftModeRequest, isInsideAnyCacheScope, isRenderDynamicLatched, markDynamicUsage, markRenderRequestApiUsage, onRenderDynamicLatched, peekDynamicUsage, peekRenderRequestApiUsage, replaceHeadersContext, restoreDraftModeTransition, runWithConnectionProbe, runWithDetachedDynamicUsage, runWithHeadersContext, runWithIsolatedDynamicUsage, setHeadersAccessPhase, setHeadersContext, suspendConnectionProbe, throwIfInsideCacheScope, throwIfStaticGenerationAccessError };

package/dist/shims/internal/app-page-props-cache-key.d.ts

@@ -5,8 +5,6 @@
  * props before a server component is invoked.
  */
 export declare const APP_PAGE_USE_CACHE_MARKER = "$$isPage";
-export declare function markAppPagePropsForUseCache<T extends object>(props: T): T;
-export declare function isMarkedAppPagePropsObject(value: object): boolean;
 /**
  * Whether `fn` is a transformed `"use cache"` function, including a bound
  * one. Like Next.js's `isUseCacheFunction`, this survives `.bind()`: React's
@@ -23,6 +21,8 @@ export declare function isUseCacheFunctionReference(fn: unknown): boolean;
  * module, or bound.
  */
 export declare function withUseCachePageMarker<T extends Record<string, unknown>>(fn: unknown, props: T): T;
+/** Layout components and their metadata resolvers retain framework params too. */
+export declare function withUseCacheLayoutMarker<T extends Record<string, unknown>>(fn: unknown, props: T): T;
 /**
  * Whether `value` is page props carrying the `$$isPage` marker. Only plain
  * objects qualify: the framework always passes a plain props object, and
@@ -30,4 +30,7 @@ export declare function withUseCachePageMarker<T extends Record<string, unknown>
  * observed as a param access.
  */
 export declare function hasUseCachePageMarker(value: unknown): value is Record<string, unknown>;
+export declare function hasUseCacheLayoutMarker(value: unknown): value is Record<string, unknown>;
+/** Remove only this invocation's marker before Flight keys and decodes props. */
+export declare function withoutUseCacheSegmentMarker(props: Record<string, unknown>, isPage: boolean): Record<string, unknown>;
 //#endregion

package/dist/shims/internal/app-page-props-cache-key.js

@@ -1,5 +1,4 @@
 //#region src/shims/internal/app-page-props-cache-key.ts
-const APP_PAGE_PROPS_CACHE_KEY_MARKER = Symbol.for("vinext.appPagePropsCacheKeyMarker");
 const USE_CACHE_FUNCTION_SYMBOL = Symbol.for("vinext.useCacheFunction");
 const SERVER_REFERENCE_TAG = Symbol.for("react.server.reference");
 /**
@@ -15,18 +14,8 @@ const USE_CACHE_SERVER_REFERENCE_ID_RE = /#\$\$vinext_cache_[0-9a-f]{64}$/;
 * props before a server component is invoked.
 */
 const APP_PAGE_USE_CACHE_MARKER = "$$isPage";
-function markAppPagePropsForUseCache(props) {
-	Object.defineProperty(props, APP_PAGE_PROPS_CACHE_KEY_MARKER, {
-		configurable: false,
-		enumerable: false,
-		value: true,
-		writable: false
-	});
-	return props;
-}
-function isMarkedAppPagePropsObject(value) {
-	return Reflect.get(value, APP_PAGE_PROPS_CACHE_KEY_MARKER) === true;
-}
+/** Layout marker, matching Next.js's `$$isLayout` prop (create-component-tree.tsx). */
+const APP_LAYOUT_USE_CACHE_MARKER = "$$isLayout";
 /**
 * Whether `fn` is a transformed `"use cache"` function, including a bound
 * one. Like Next.js's `isUseCacheFunction`, this survives `.bind()`: React's
@@ -53,6 +42,13 @@ function withUseCachePageMarker(fn, props) {
 		[APP_PAGE_USE_CACHE_MARKER]: true
 	} : props;
 }
+/** Layout components and their metadata resolvers retain framework params too. */
+function withUseCacheLayoutMarker(fn, props) {
+	return isUseCacheFunctionReference(fn) ? {
+		...props,
+		[APP_LAYOUT_USE_CACHE_MARKER]: true
+	} : props;
+}
 /**
 * Whether `value` is page props carrying the `$$isPage` marker. Only plain
 * objects qualify: the framework always passes a plain props object, and
@@ -60,9 +56,22 @@ function withUseCachePageMarker(fn, props) {
 * observed as a param access.
 */
 function hasUseCachePageMarker(value) {
+	return hasUseCacheSegmentMarker(value, APP_PAGE_USE_CACHE_MARKER);
+}
+function hasUseCacheLayoutMarker(value) {
+	return hasUseCacheSegmentMarker(value, APP_LAYOUT_USE_CACHE_MARKER);
+}
+/** Remove only this invocation's marker before Flight keys and decodes props. */
+function withoutUseCacheSegmentMarker(props, isPage) {
+	const marker = isPage ? APP_PAGE_USE_CACHE_MARKER : APP_LAYOUT_USE_CACHE_MARKER;
+	if (props[marker] !== true) return props;
+	const { [marker]: _marker, ...segmentProps } = props;
+	return segmentProps;
+}
+function hasUseCacheSegmentMarker(value, marker) {
 	if (value === null || typeof value !== "object") return false;
 	const prototype = Object.getPrototypeOf(value);
-	return (prototype === Object.prototype || prototype === null) && value["$$isPage"] === true;
+	return (prototype === Object.prototype || prototype === null) && value[marker] === true;
 }
 //#endregion
-export { APP_PAGE_USE_CACHE_MARKER, hasUseCachePageMarker, isMarkedAppPagePropsObject, isUseCacheFunctionReference, markAppPagePropsForUseCache, withUseCachePageMarker };
+export { APP_PAGE_USE_CACHE_MARKER, hasUseCacheLayoutMarker, hasUseCachePageMarker, isUseCacheFunctionReference, withUseCacheLayoutMarker, withUseCachePageMarker, withoutUseCacheSegmentMarker };

package/dist/shims/internal/headers-state.d.ts

@@ -30,7 +30,6 @@ export type ConnectionProbeState = {
   dynamicUsageTarget: VinextHeadersShimState;
   interrupted: boolean;
   interrupt: () => void;
-  pending: Promise<never>;
 };
 export type ConnectionProbeResult<T> = {
   completed: true;

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,16 +2,16 @@ 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";
@@ -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/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.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,