vinext 1.0.1 → 1.2.0

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/image.js

@@ -258,6 +258,7 @@ function extractLocalDeploymentId(src) {
 		deploymentId
 	};
 }
+const __imageEndpoint = `${process.env.__NEXT_ROUTER_BASEPATH ?? ""}/_next/image${process.env.__VINEXT_TRAILING_SLASH === "true" ? "/" : ""}`;
 /**
 * Build a `/_next/image` optimization URL.
 *
@@ -268,7 +269,7 @@ function extractLocalDeploymentId(src) {
 function imageOptimizationUrl(src, width, quality = 75) {
 	const source = extractLocalDeploymentId(src);
 	const deploymentQuery = source.src.startsWith("/") && source.deploymentId ? `&dpl=${source.deploymentId}` : "";
-	return `/_next/image?url=${encodeURIComponent(source.src)}&w=${width}&q=${quality}${deploymentQuery}`;
+	return `${__imageEndpoint}?url=${encodeURIComponent(source.src)}&w=${width}&q=${quality}${deploymentQuery}`;
 }
 function preloadImageResource(input) {
 	if (!input.shouldPreload) return;

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/internal/work-store-scope.d.ts

@@ -0,0 +1,5 @@
+//#region src/shims/internal/work-store-scope.d.ts
+export declare function runInWorkStoreScope<T>(fn: () => T): T;
+export declare function runOutsideWorkStoreScope<T>(fn: () => T): T;
+export declare function isInsideWorkStoreScope(): boolean;
+//#endregion

package/dist/shims/internal/work-store-scope.js

@@ -0,0 +1,24 @@
+import { getOrCreateAls } from "./als-registry.js";
+//#region src/shims/internal/work-store-scope.ts
+/**
+* Marks the work that Next.js runs with a work store (`workAsyncStorage`):
+* App Router renders, Server Actions, route handlers and metadata routes,
+* `generateStaticParams`, and middleware. Pages Router renders, API routes
+* and `getStaticPaths` run without one.
+*
+* Next.js only applies some rules inside a work store, such as skipping the
+* read for an `unstable_cache` nested in another's callback.
+* Source: https://github.com/vercel/next.js/blob/canary/packages/next/src/server/web/spec-extension/unstable-cache.ts
+*/
+const _workStoreScopeAls = getOrCreateAls("vinext.workStoreScope.als");
+function runInWorkStoreScope(fn) {
+	return _workStoreScopeAls.run(true, fn);
+}
+function runOutsideWorkStoreScope(fn) {
+	return _workStoreScopeAls.run(false, fn);
+}
+function isInsideWorkStoreScope() {
+	return _workStoreScopeAls.getStore() === true;
+}
+//#endregion
+export { isInsideWorkStoreScope, runInWorkStoreScope, runOutsideWorkStoreScope };

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,21 +2,22 @@ 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 { disableSmoothScrollDuringRouteTransition } from "./disable-smooth-scroll.js";
+import { retryScrollTo, scrollToHashTarget } 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 { VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, createRscRequestHeaders, createRscRequestUrl, stripRscCacheBustingSearchParam, stripRscSuffix } from "../server/app-rsc-cache-busting.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";
@@ -662,6 +663,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 +673,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 +744,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,
@@ -791,6 +798,22 @@ async function fetchRouteTreeGatedPrefetch(options) {
 	return fetchFullRscPayload();
 }
 /**
+* Whether a prefetch response may be decoded as Flight. A successful response
+* that is not Flight (e.g. a Route Handler's text download) is a miss: decoding
+* its bytes would let text shaped like Flight resource hints insert scripts.
+* Navigation then fetches it and falls back to a document navigation.
+*
+* Ported from Next.js: fetchPrefetchResponse in
+* packages/next/src/client/components/segment-cache/cache.ts, which skips the
+* check in `output: "export"` because a static host, not Next.js, chooses the
+* MIME type of the exported `.txt` payloads.
+*/
+function isFlightPrefetchResponse(response) {
+	if (!response.ok) return false;
+	if (process.env.NODE_ENV === "production" && process.env.__NEXT_CONFIG_OUTPUT === "export") return true;
+	return response.headers.get("content-type")?.toLowerCase().startsWith(VINEXT_RSC_CONTENT_TYPE) === true;
+}
+/**
 * Prefetch an RSC response and snapshot it for later consumption.
 * Stores the in-flight promise so immediate clicks can await it instead
 * of firing a duplicate fetch.
@@ -818,7 +841,7 @@ function prefetchRscResponse(rscUrl, fetchPromise, interceptionContext = null, m
 	addPrefetchInvalidationCallback(entry, options?.onInvalidate);
 	entry.fetchPromise = fetchPromise;
 	entry.pending = fetchPromise.then(async (response) => {
-		if (response.ok) {
+		if (isFlightPrefetchResponse(response)) {
 			const snapshot = await snapshotRscResponse(response);
 			if (cache.get(cacheKey) !== entry) return;
 			const previousSize = getPrefetchCacheEntrySize(entry);
@@ -826,7 +849,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;
@@ -835,6 +858,7 @@ function prefetchRscResponse(rscUrl, fetchPromise, interceptionContext = null, m
 			evictPrefetchCacheIfNeeded();
 		} else {
 			releaseAppPrefetchFetchSlot(response);
+			response.body?.cancel().catch(() => {});
 			deletePrefetchCacheEntry(cache, prefetched, cacheKey, entry, false);
 		}
 	}).catch(() => {
@@ -1327,11 +1351,19 @@ function commitHashOnlyHistoryState(href, mode, scroll) {
 function applyAppRouterScrollFallback(intent) {
 	if (typeof document === "undefined" || typeof window === "undefined") return;
 	if (intent.hash !== null) {
-		scrollToHashTargetOnNextFrame(intent.hash, () => isLatestAppRouterScrollIntent(intent));
+		const hash = intent.hash;
+		requestAnimationFrame(() => {
+			if (!isLatestAppRouterScrollIntent(intent)) return;
+			disableSmoothScrollDuringRouteTransition(() => {
+				scrollToHashTarget(hash);
+			});
+		});
 		return;
 	}
 	if (intent.targetHoistedInHead) return;
-	document.documentElement.scrollTop = 0;
+	disableSmoothScrollDuringRouteTransition(() => {
+		document.documentElement.scrollTop = 0;
+	});
 }
 function scheduleAppRouterScrollFallback(intent) {
 	queueMicrotask(() => {
@@ -1781,6 +1813,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 +1825,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 +1842,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,17 @@ export type ExecutionContextLike = {
   isInternalPagesRevalidation?: boolean;
   /** Marks a build-secret-authorized Worker request that may run prerender discovery hooks. */
   isPrerenderPathDiscovery?: boolean;
+  /** Marks an adapter-invoked regeneration of an entry stored for this build. */
+  isStoredEntryRegeneration?: 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

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

package/dist/shims/router.js

@@ -1,6 +1,7 @@
 import { isUnknownRecord } from "../utils/record.js";
 import { parseCookieHeader } from "../utils/parse-cookie.js";
 import { isExternalUrl } from "../utils/external-url.js";
+import { substituteDestinationParams } from "../config/destination-params.js";
 import { sortRoutes, splitPathSegments } from "../routing/utils.js";
 import { hasBasePath, removeTrailingSlash, stripBasePath } from "../utils/base-path.js";
 import { assertSafeNavigationUrl } from "./url-safety.js";
@@ -19,6 +20,7 @@ import { resolveDirectHybridClientRouteOwner } from "./internal/hybrid-client-ro
 import { installWindowNext } from "../client/window-next.js";
 import { getWindowOrigin, isAbsoluteOrProtocolRelativeUrl, isAbsoluteUrl, isHashOnlyBrowserUrlChange, normalizePathTrailingSlash, toBrowserNavigationHref, toSameOriginAppPath, toSameOriginPath, withBasePath } from "./url-utils.js";
 import { addQueryParam, mergeRewriteQuery, mergeRouteParamsIntoQuery, parseQueryString } from "../utils/query.js";
+import { disableSmoothScrollDuringRouteTransition } from "./disable-smooth-scroll.js";
 import { scrollToHashTarget } from "./hash-scroll.js";
 import { installPagesRouterRuntime, setPagesRouterPopStateHandler, setStampInitialHistoryState } from "./pages-router-runtime.js";
 import { interpolateDynamicRouteHref, resolveDynamicRouteHref } from "./internal/interpolate-as.js";
@@ -129,16 +131,9 @@ function scrollToPagesRouterPosition({ x, y }) {
 		window.scrollTo(x, y);
 		return;
 	}
-	const htmlElement = document.documentElement;
-	if (!(htmlElement.dataset.scrollBehavior === "smooth")) {
+	disableSmoothScrollDuringRouteTransition(() => {
 		window.scrollTo(x, y);
-		return;
-	}
-	const previousScrollBehavior = htmlElement.style.scrollBehavior;
-	htmlElement.style.scrollBehavior = "auto";
-	htmlElement.getClientRects();
-	window.scrollTo(x, y);
-	htmlElement.style.scrollBehavior = previousScrollBehavior;
+	});
 }
 function isAtScrollPosition({ x, y }) {
 	return Math.abs(window.scrollX - x) <= SCROLL_RESTORE_TOLERANCE_PX && Math.abs(window.scrollY - y) <= SCROLL_RESTORE_TOLERANCE_PX;
@@ -1020,10 +1015,10 @@ async function resolveClientConfigRedirect(href) {
 	if (!redirects || redirects.length === 0) return null;
 	const routeContext = getClientConfigRouteContext(href);
 	if (!routeContext) return null;
-	const { matchRedirect, preserveRedirectDestinationQuery } = await import("../config/config-matchers.js");
-	const redirect = matchRedirect(routeContext.pathname, redirects, routeContext.context, routeContext.basePathState);
+	const [{ matchClientRedirect }, { preserveRedirectDestinationQuery }] = await Promise.all([import("../client/client-redirect-matcher.js"), import("../config/config-matchers.js")]);
+	const redirect = matchClientRedirect(routeContext.pathname, redirects, routeContext.context, routeContext.basePathState);
 	if (!redirect) return null;
-	return preserveRedirectDestinationQuery(__basePath && routeContext.basePathState.hadBasePath && !isExternalUrl(redirect.destination) && !hasBasePath(redirect.destination, __basePath) ? __basePath + redirect.destination : redirect.destination, routeContext.search);
+	return preserveRedirectDestinationQuery(__basePath && routeContext.basePathState.hadBasePath && !isExternalUrl(redirect.destination) && !hasBasePath(redirect.destination, __basePath) ? __basePath + redirect.destination : redirect.destination, routeContext.search, redirect.destinationQuery);
 }
 async function applyClientConfigRewrite(href, rewrite) {
 	const routeContext = getClientConfigRouteContext(href);
@@ -1076,12 +1071,6 @@ function simpleClientConfigSourceCouldMatch(pathname, source) {
 	const normalizedPathname = removeTrailingSlash(pathname);
 	return normalizedPathname === normalizedPrefix || normalizedPathname.startsWith(`${normalizedPrefix}/`);
 }
-function substituteSimpleClientConfigDestination(destination, params) {
-	const keys = Object.keys(params);
-	if (keys.length === 0) return destination;
-	const alternation = keys.sort((a, b) => b.length - a.length).map((key) => key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
-	return destination.replace(new RegExp(`:(${alternation})([+*])?(?![A-Za-z0-9_])`, "g"), (_token, key) => params[key] ?? _token);
-}
 function isExternalClientConfigUrl(url) {
 	return /^[a-z][a-z0-9+.-]*:/i.test(url) || url.startsWith("//");
 }
@@ -1111,7 +1100,7 @@ function resolveClientConfigRewriteSync(href) {
 		const params = matchSimpleClientConfigPattern(routeContext.pathname, rewrite.source);
 		if (params === void 0) return void 0;
 		if (params === null) continue;
-		const rewritten = substituteSimpleClientConfigDestination(rewrite.destination, params);
+		const rewritten = substituteDestinationParams(rewrite.destination, params, "rewrite");
 		if (isExternalClientConfigUrl(rewritten)) return { kind: "document" };
 		currentHref = mergeRewriteQuery(currentHref, rewritten);
 		matched = true;
@@ -2018,7 +2007,10 @@ See more info: https://nextjs.org/docs/messages/invalid-relative-url-external-as
 		emitBeforeHistoryChange();
 		if (doScroll) {
 			if (hash) scrollToHashTarget(hash);
-			else window.scrollTo(0, 0);
+			else scrollToPagesRouterPosition({
+				x: 0,
+				y: 0
+			});
 		}
 	}
 	onStateUpdate?.();

package/dist/shims/server.d.ts

@@ -26,6 +26,7 @@ export type RequestInit = globalThis.RequestInit & {
       }>;
     } | null;
     trailingSlash?: boolean;
+    skipTrailingSlashRedirect?: boolean;
   };
   signal?: AbortSignal;
   duplex?: "half";
@@ -109,6 +110,14 @@ export type NextURLConfig = {
      * honour the user's `trailingSlash` config.
      */
     trailingSlash?: boolean;
+    /**
+     * When true, the trailing slash follows the parsed URL instead, and
+     * `trailingSlash` only decides the root, like Next.js's
+     * getNextPathnameInfo. Without the trailing-slash redirect, requests
+     * arrive in either form, so the config can no longer be applied as a
+     * policy.
+     */
+    skipTrailingSlashRedirect?: boolean;
   };
 };
 export declare class NextURL {
@@ -121,6 +130,8 @@ export declare class NextURL {
    */
   private _configBasePath;
   private _basePath;
+  private _configTrailingSlash;
+  private _manualTrailingSlash;
   private _trailingSlash;
   private _locale;
   private _configDefaultLocale;
@@ -129,6 +140,11 @@ export declare class NextURL {
   private _domains;
   private _domainLocale;
   constructor(input: string | URL, base?: string | URL, config?: NextURLConfig);
+  /**
+   * With `skipTrailingSlashRedirect`, take the slash from the parsed pathname
+   * (before basePath and locale are stripped), as getNextPathnameInfo does.
+   */
+  private _analyzeTrailingSlash;
   /** Strip basePath prefix from the internal pathname.
    * Mirrors Next.js's getNextPathnameInfo (re-run by NextURL.analyze() on
    * every parse, including `href` reassignment): basePath is only considered