vinext 1.0.1 → 1.2.0

package/dist/shims/cache.js

@@ -1,18 +1,19 @@
 import { getOrCreateAls } from "./internal/als-registry.js";
 import { getRequestContext, isInsideUnifiedScope } from "./unified-request-context.js";
 import { getRequestExecutionContext, runWithExecutionContext } from "./request-context.js";
+import { isInsideWorkStoreScope } from "./internal/work-store-scope.js";
 import { workUnitAsyncStorage } from "./internal/work-unit-async-storage.js";
 import { getCdnCacheAdapter } from "./cdn-cache.js";
 import { isStagedCacheabilityProbeActive } from "./cacheability-classification.js";
-import { fnv1a64 } from "../utils/hash.js";
 import { MemoryCacheHandler, NoOpCacheHandler, configureMemoryCacheHandler, getCacheHandler, getDataCacheHandler, registerDataCacheHandler, registerLazyDataCacheHandler, setCacheHandler, setDataCacheHandler } from "./cache-handler.js";
 import { encodeCacheTag, encodeCacheTags } from "../utils/encode-cache-tag.js";
+import { fnv1a64, sha256Hex } from "../utils/hash.js";
+import { addCollectedRequestTags, getCurrentFetchSoftTags, runWithDetachedFetchObservations } from "./fetch-cache-state.js";
 import { makeHangingPromise } from "./internal/make-hanging-promise.js";
 import { getHeadersAccessPhase, markDynamicUsage } from "./internal/headers-state.js";
 import { isDraftModeEnabled } from "./headers.js";
 import { _recordUseCacheRootParamRead, _registerCacheContextAccessor, getRegisteredCacheContext } from "./internal/cache-context-accessor.js";
-import { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingRevalidation, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, markActionRevalidation, recordUnstableCacheObservation, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
-import { addCollectedRequestTags, getCurrentFetchSoftTags } from "./fetch-cache.js";
+import { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingRevalidation, _runWithCacheState, _setRequestScopedCacheLife, cacheLifeProfiles, getAndClearActionRevalidationKind, markActionRevalidation, recordUnstableCacheObservation, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
 //#region src/shims/cache.ts
 /**
 * next/cache shim
@@ -322,6 +323,8 @@ const UNSTABLE_CACHE_KEY_PREFIX = "unstable_cache:v2";
 * a direct import (avoiding circular dependencies).
 */
 const _unstableCacheAls = getOrCreateAls("vinext.unstableCache.als");
+const _useCacheContextAls = getOrCreateAls("vinext.cacheRuntime.contextAls");
+const _unstableCacheCallbackAls = getOrCreateAls("vinext.unstableCache.callbackAls");
 function serializeUnstableCacheResult(value) {
 	return JSON.stringify(value === void 0 ? { undef: true } : { v: value });
 }
@@ -347,6 +350,18 @@ function tryDeserializeUnstableCacheResult(body) {
 function isInsideUnstableCacheScope() {
 	return _unstableCacheAls.getStore() === true;
 }
+/**
+* Whether an unstable_cache call is nested in another one's callback, as
+* Next.js's `isNestedUnstableCache` decides: only where Next.js has a work
+* store (not in Pages Router or outside a render), and only when the
+* innermost cache scope is that callback rather than a "use cache" function
+* it called.
+* Source: https://github.com/vercel/next.js/blob/canary/packages/next/src/server/web/spec-extension/unstable-cache.ts
+*/
+function isNestedUnstableCacheCall() {
+	const callback = _unstableCacheCallbackAls.getStore();
+	return callback !== void 0 && callback.useCacheContext === _useCacheContextAls.getStore() && isInsideWorkStoreScope();
+}
 const _UNSTABLE_CACHE_PENDING_REVALIDATIONS_KEY = Symbol.for("vinext.unstableCache.pendingRevalidations");
 function getPendingUnstableCacheRevalidations() {
 	const existing = _g[_UNSTABLE_CACHE_PENDING_REVALIDATIONS_KEY];
@@ -362,7 +377,7 @@ function waitUntilUnstableCacheRevalidation(promise) {
 function scheduleUnstableCacheBackgroundRevalidation(cacheKey, refresh) {
 	const pending = getPendingUnstableCacheRevalidations();
 	if (pending.has(cacheKey)) return;
-	const trackedRevalidation = refresh().then(() => void 0).catch((err) => {
+	const trackedRevalidation = runWithDetachedCacheObservations(() => runWithDetachedFetchObservations(() => _useCacheContextAls.exit(refresh))).then(() => void 0).catch((err) => {
 		console.error(`[vinext] unstable_cache background revalidation failed for ${cacheKey}:`, err);
 	}).finally(() => {
 		if (pending.get(cacheKey) === trackedRevalidation) pending.delete(cacheKey);
@@ -370,8 +385,10 @@ function scheduleUnstableCacheBackgroundRevalidation(cacheKey, refresh) {
 	pending.set(cacheKey, trackedRevalidation);
 	waitUntilUnstableCacheRevalidation(trackedRevalidation);
 }
-async function refreshUnstableCacheResult(fn, args, cacheKey, tags, revalidateSeconds) {
-	const result = await _unstableCacheAls.run(true, () => fn(...args));
+async function refreshUnstableCacheResult(fn, args, keyedArgs, cacheKey, tags, revalidateSeconds) {
+	const argsUnchanged = serializeArgsOrNull(args) === keyedArgs;
+	const result = await _unstableCacheAls.run(true, () => _unstableCacheCallbackAls.run({ useCacheContext: _useCacheContextAls.getStore() }, () => fn(...args)));
+	if (!argsUnchanged) return result;
 	const cacheValue = {
 		kind: "FETCH",
 		data: {
@@ -389,29 +406,40 @@ async function refreshUnstableCacheResult(fn, args, cacheKey, tags, revalidateSe
 	});
 	return result;
 }
+function serializeArgsOrNull(args) {
+	try {
+		return JSON.stringify(args);
+	} catch {
+		return null;
+	}
+}
 /**
 * Wrap an async function with caching.
 *
-* Returns a new function that caches results. The cache key is derived
-* from keyParts + serialized arguments.
+* Returns a new function that caches results. The cache key is a SHA-256
+* digest of the callback source, keyParts and serialized arguments.
 */
 function unstable_cache(fn, keyParts, options) {
-	const baseKey = keyParts ? keyParts.join(":") : fnv1a64(fn.toString());
+	if (typeof window !== "undefined") return function cached(...args) {
+		return fn.apply(this, args);
+	};
+	const fixedKey = JSON.stringify([fn.toString(), keyParts ?? null]);
 	const tags = encodeCacheTags(options?.tags ?? []);
 	const revalidateSeconds = options?.revalidate;
 	const cachedFn = async (...args) => {
-		const argsKey = JSON.stringify(args);
-		const cacheKey = `${UNSTABLE_CACHE_KEY_PREFIX}:${baseKey}:${argsKey}`;
+		const keyedArgs = JSON.stringify(args);
+		const invocationKey = `${fixedKey}${keyedArgs}`;
 		addCollectedRequestTags(tags);
 		recordUnstableCacheObservation({
 			kind: "unstable_cache",
-			keyHash: fnv1a64(cacheKey),
+			keyHash: fnv1a64(invocationKey),
 			revalidate: typeof revalidateSeconds === "number" ? revalidateSeconds : revalidateSeconds === false ? false : null,
 			tagCount: tags.length,
 			tagHash: tags.length > 0 ? fnv1a64(JSON.stringify(tags)) : null
 		});
+		const cacheKey = `${UNSTABLE_CACHE_KEY_PREFIX}:${await sha256Hex(invocationKey)}`;
 		const isDraftMode = isDraftModeEnabled();
-		if (!isDraftMode) {
+		if (!isDraftMode && !isNestedUnstableCacheCall()) {
 			const softTags = getCurrentFetchSoftTags();
 			const existing = _hasPendingRevalidatedTag([...tags, ...softTags]) ? null : await getDataCacheHandler().get(cacheKey, {
 				kind: "FETCH",
@@ -423,7 +451,7 @@ function unstable_cache(fn, keyParts, options) {
 				if (cached.ok) {
 					if (existing.cacheState === "stale") {
 						if (shouldServeStaleUnstableCacheEntry()) {
-							scheduleUnstableCacheBackgroundRevalidation(cacheKey, () => refreshUnstableCacheResult(fn, args, cacheKey, tags, revalidateSeconds));
+							scheduleUnstableCacheBackgroundRevalidation(cacheKey, () => refreshUnstableCacheResult(fn, args, keyedArgs, cacheKey, tags, revalidateSeconds));
 							return cached.value;
 						}
 					} else return cached.value;
@@ -431,9 +459,9 @@ function unstable_cache(fn, keyParts, options) {
 			}
 		}
 		if (isDraftMode) return await _unstableCacheAls.run(true, () => fn(...args));
-		return await refreshUnstableCacheResult(fn, args, cacheKey, tags, revalidateSeconds);
+		return await refreshUnstableCacheResult(fn, args, keyedArgs, cacheKey, tags, revalidateSeconds);
 	};
 	return cachedFn;
 }
 //#endregion
-export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, MemoryCacheHandler, NoOpCacheHandler, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _runWithCacheState, _setRequestScopedCacheLife, cacheLife, cacheLifeProfiles, cacheTag, configureMemoryCacheHandler, getAndClearActionRevalidationKind, getCacheHandler, getDataCacheHandler, getRegisteredCacheContext, getRequestExecutionContext, io, isInsideUnstableCacheScope, markActionRevalidation, unstable_noStore as noStore, unstable_noStore, recordUnstableCacheObservation, refresh, registerDataCacheHandler, registerLazyDataCacheHandler, revalidatePath, revalidateTag, runWithExecutionContext, setCacheHandler, setDataCacheHandler, shouldServeStaleUnstableCacheEntry, unstable_cache, unstable_cacheLife, unstable_cacheTag, unstable_io, updateTag };
+export { ACTION_DID_REVALIDATE_DYNAMIC_ONLY, ACTION_DID_REVALIDATE_STATIC_AND_DYNAMIC, MemoryCacheHandler, NoOpCacheHandler, _captureRequestScopedCacheLifeAccessors, _consumeRequestScopedCacheLife, _drainPendingRevalidations, _hasPendingRevalidatedTag, _initRequestScopedCacheState, _markPendingRevalidatedTag, _peekRequestScopedCacheLife, _peekUnstableCacheObservations, _queuePendingRevalidation, _recordUseCacheRootParamRead, _registerCacheContextAccessor, _runWithCacheState, _setRequestScopedCacheLife, cacheLife, cacheLifeProfiles, cacheTag, configureMemoryCacheHandler, getAndClearActionRevalidationKind, getCacheHandler, getDataCacheHandler, getRegisteredCacheContext, getRequestExecutionContext, io, isInsideUnstableCacheScope, markActionRevalidation, unstable_noStore as noStore, unstable_noStore, recordUnstableCacheObservation, refresh, registerDataCacheHandler, registerLazyDataCacheHandler, revalidatePath, revalidateTag, runWithDetachedCacheObservations, runWithExecutionContext, setCacheHandler, setDataCacheHandler, shouldServeStaleUnstableCacheEntry, unstable_cache, unstable_cacheLife, unstable_cacheTag, unstable_io, updateTag };

package/dist/shims/cacheability-classification.d.ts

@@ -10,6 +10,13 @@ export type RouteCacheabilityOutcome = {
   searchParamsUnread?: true;
   /** A transient classification failure that may succeed on another bounded attempt. */
   retryable?: true;
+  /**
+   * App page RSC: the status and headers that replace the streamed 200 of a
+   * render whose special error rejected its document's shell, once the
+   * response is complete.
+   */
+  status?: number;
+  headers?: Readonly<Record<string, string>>;
   tags?: readonly string[];
 };
 export type RouteCacheabilityState = {

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

@@ -54,6 +54,8 @@ export type CdnResponsePolicy = {
 export declare function splitCacheControlDirectives(cacheControl: string): string[];
 /** Whether a Cache-Control value contains an exact non-cacheable directive. */
 export declare function isNonCacheableCacheControl(cacheControl: string, scope?: "shared" | "browser"): boolean;
+/** Whether a request carries credentials a shared response cache must not capture. */
+export declare function hasSharedCacheCredentials(headers: Headers): boolean;
 /**
  * The serving strategy for page-level ISR. Implement this to delegate
  * page/route/image caching to a CDN edge instead of the origin store.
@@ -88,6 +90,12 @@ export type CdnCacheAdapter = {
   deferCompletedPageResponseAdmission?(response: Response, complete: (response: Response) => Promise<Response>): Response | null;
   /** Capture the full-route RSC side stream while admitting a completed HTML response. */
   captureAppPageRscData?(rscData: Promise<ArrayBuffer>): void;
+  /**
+   * Whether this adapter sends the 304 for a Pages render whose If-None-Match
+   * matches. When it does, the render returns the page, so an adapter that
+   * stores completed responses stores the page rather than the 304.
+   */
+  deferNotModifiedResponse?(): boolean;
   /**
    * Validate provider-specific request routing before the application handles
    * the request. Returning a response short-circuits the request pipeline;

package/dist/shims/cdn-cache.js

@@ -31,6 +31,22 @@ function isNonCacheableCacheControl(cacheControl, scope = "shared") {
 		return name === "no-store" || equals === -1 && (name === "no-cache" || scope === "shared" && name === "private");
 	});
 }
+/**
+* Request headers that identify the caller. A shared response cache never
+* admits a Route Handler or API response's own policy for a request carrying
+* them, and never replays such a render to refill its data entries.
+* `x-api-key` matches the fetch cache's credential headers.
+*/
+const SHARED_CACHE_CREDENTIAL_HEADERS = [
+	"authorization",
+	"cookie",
+	"proxy-authorization",
+	"x-api-key"
+];
+/** Whether a request carries credentials a shared response cache must not capture. */
+function hasSharedCacheCredentials(headers) {
+	return SHARED_CACHE_CREDENTIAL_HEADERS.some((name) => headers.has(name));
+}
 const PENDING_DYNAMIC_CACHE_CONTROL = "no-store, must-revalidate";
 /**
 * Default origin-managed ISR strategy: store page artifacts in the data cache,
@@ -95,4 +111,4 @@ function getCdnCacheAdapter() {
 	return _defaultAdapter ??= new DefaultCdnCacheAdapter();
 }
 //#endregion
-export { DefaultCdnCacheAdapter, getCdnCacheAdapter, isNonCacheableCacheControl, setCdnCacheAdapter, splitCacheControlDirectives };
+export { DefaultCdnCacheAdapter, getCdnCacheAdapter, hasSharedCacheCredentials, isNonCacheableCacheControl, setCdnCacheAdapter, splitCacheControlDirectives };

package/dist/shims/disable-smooth-scroll.d.ts

@@ -0,0 +1,3 @@
+//#region src/shims/disable-smooth-scroll.d.ts
+export declare function disableSmoothScrollDuringRouteTransition(fn: () => void): void;
+//#endregion

package/dist/shims/disable-smooth-scroll.js

@@ -0,0 +1,36 @@
+//#region src/shims/disable-smooth-scroll.ts
+/**
+* Run a route-transition scroll with `scroll-behavior: auto` on `<html>`.
+*
+* Ported from Next.js:
+* packages/next/src/shared/lib/router/utils/disable-smooth-scroll.ts
+*
+* Since Next.js 16 (vercel/next.js#84102) the override is opt-in: it only
+* applies when the root element carries `data-scroll-behavior="smooth"`.
+* Without the attribute, a page-level `scroll-behavior: smooth` is respected
+* and route-change scrolls animate (development warns once about the missing
+* opt-in). Hash-only navigations never use this helper, so in-page anchor
+* jumps keep the smooth behavior.
+*/
+let warnedMissingDataScrollBehavior = false;
+function disableSmoothScrollDuringRouteTransition(fn) {
+	const htmlElement = document.documentElement;
+	if (htmlElement.dataset.scrollBehavior !== "smooth") {
+		if (process.env.NODE_ENV === "development" && !warnedMissingDataScrollBehavior && getComputedStyle(htmlElement).scrollBehavior === "smooth") {
+			warnedMissingDataScrollBehavior = true;
+			console.warn("Detected `scroll-behavior: smooth` on the `<html>` element. To disable smooth scrolling during route transitions, add `data-scroll-behavior=\"smooth\"` to your <html> element. Learn more: https://nextjs.org/docs/messages/missing-data-scroll-behavior");
+		}
+		fn();
+		return;
+	}
+	const previousScrollBehavior = htmlElement.style.scrollBehavior;
+	htmlElement.style.scrollBehavior = "auto";
+	htmlElement.getClientRects();
+	try {
+		fn();
+	} finally {
+		htmlElement.style.scrollBehavior = previousScrollBehavior;
+	}
+}
+//#endregion
+export { disableSmoothScrollDuringRouteTransition };

package/dist/shims/document-placeholders.d.ts

@@ -0,0 +1,19 @@
+import React from "react";
+//#region src/shims/document-placeholders.d.ts
+/** Attribute `<Head>` adds last on its opening tag. */
+export declare const DOCUMENT_HEAD_OPEN_ATTRIBUTE = "data-vinext-head-open";
+/** Attribute of the `<template>` `<Head>` renders as its last child. */
+export declare const DOCUMENT_HEAD_CLOSE_ATTRIBUTE = "data-vinext-head-close";
+export declare function createDocumentPlaceholderToken(): string;
+export declare function withDocumentPlaceholders(element: React.ReactElement, token: string): React.ReactElement;
+export declare function useDocumentPlaceholderToken(): string | null;
+/**
+ * `<Main />`'s placeholder. Without a renderer-provided token (a Document
+ * rendered on its own, e.g. in tests) it falls back to a static comment.
+ */
+export declare function getDocumentMainPlaceholder(token: string | null): string;
+export declare function getDocumentScriptsPlaceholder(token: string | null): string;
+/** The marker attribute on `<Head>`'s opening tag. */
+export declare function getDocumentHeadOpenMarker(token: string): string;
+export declare function getDocumentHeadCloseMarker(token: string): string;
+//#endregion

package/dist/shims/document-placeholders.js

@@ -0,0 +1,45 @@
+import React from "react";
+//#region src/shims/document-placeholders.ts
+/**
+* Per-render placeholders for the Pages Router `next/document` shims.
+*
+* The renderers splice the page body, `next/head` output, asset tags and
+* hydration scripts into the serialized custom Document. Each render provides
+* a fresh random token, and `<Head>`, `<Main />` and `<NextScript />` mark
+* their splice points with it. Nothing the Document renders, request data in
+* raw `<script>` text included, can know the token, so nothing can be mistaken
+* for a splice point.
+*/
+const DocumentPlaceholderContext = React.createContext(null);
+/** Attribute `<Head>` adds last on its opening tag. */
+const DOCUMENT_HEAD_OPEN_ATTRIBUTE = "data-vinext-head-open";
+/** Attribute of the `<template>` `<Head>` renders as its last child. */
+const DOCUMENT_HEAD_CLOSE_ATTRIBUTE = "data-vinext-head-close";
+function createDocumentPlaceholderToken() {
+	return crypto.randomUUID();
+}
+function withDocumentPlaceholders(element, token) {
+	return React.createElement(DocumentPlaceholderContext.Provider, { value: token }, element);
+}
+function useDocumentPlaceholderToken() {
+	return React.useContext(DocumentPlaceholderContext);
+}
+/**
+* `<Main />`'s placeholder. Without a renderer-provided token (a Document
+* rendered on its own, e.g. in tests) it falls back to a static comment.
+*/
+function getDocumentMainPlaceholder(token) {
+	return token ? `<!--__NEXT_MAIN__:${token}-->` : "<!-- __NEXT_MAIN__ -->";
+}
+function getDocumentScriptsPlaceholder(token) {
+	return token ? `<!--__NEXT_SCRIPTS__:${token}-->` : "<!-- __NEXT_SCRIPTS__ -->";
+}
+/** The marker attribute on `<Head>`'s opening tag. */
+function getDocumentHeadOpenMarker(token) {
+	return ` ${DOCUMENT_HEAD_OPEN_ATTRIBUTE}="${token}"`;
+}
+function getDocumentHeadCloseMarker(token) {
+	return `<template ${DOCUMENT_HEAD_CLOSE_ATTRIBUTE}="${token}"></template>`;
+}
+//#endregion
+export { DOCUMENT_HEAD_CLOSE_ATTRIBUTE, DOCUMENT_HEAD_OPEN_ATTRIBUTE, createDocumentPlaceholderToken, getDocumentHeadCloseMarker, getDocumentHeadOpenMarker, getDocumentMainPlaceholder, getDocumentScriptsPlaceholder, useDocumentPlaceholderToken, withDocumentPlaceholders };

package/dist/shims/document.js

@@ -1,4 +1,5 @@
 import { safeJsonStringify } from "../server/html.js";
+import { DOCUMENT_HEAD_CLOSE_ATTRIBUTE, DOCUMENT_HEAD_OPEN_ATTRIBUTE, getDocumentMainPlaceholder, getDocumentScriptsPlaceholder, useDocumentPlaceholderToken } from "./document-placeholders.js";
 import React from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 //#region src/shims/document.tsx
@@ -47,7 +48,7 @@ var Head = class extends React.Component {
 	}
 	render() {
 		const { children, nonce, crossOrigin, ...props } = this.props;
-		return /* @__PURE__ */ jsx("head", {
+		return /* @__PURE__ */ jsx(DocumentHeadElement, {
 			...props,
 			...nonce ? { [documentAssetMarkerAttributes.headNonce]: nonce } : {},
 			...crossOrigin ? { [documentAssetMarkerAttributes.headCrossOrigin]: crossOrigin } : {},
@@ -55,10 +56,19 @@ var Head = class extends React.Component {
 		});
 	}
 };
+function DocumentHeadElement({ children, ...props }) {
+	const token = useDocumentPlaceholderToken();
+	return /* @__PURE__ */ jsxs("head", {
+		...props,
+		...token ? { [DOCUMENT_HEAD_OPEN_ATTRIBUTE]: token } : {},
+		children: [children, token ? /* @__PURE__ */ jsx("template", { [DOCUMENT_HEAD_CLOSE_ATTRIBUTE]: token }) : null]
+	});
+}
 function Main() {
+	const token = useDocumentPlaceholderToken();
 	return /* @__PURE__ */ jsx("div", {
 		id: "__next",
-		dangerouslySetInnerHTML: { __html: "__NEXT_MAIN__" }
+		dangerouslySetInnerHTML: { __html: getDocumentMainPlaceholder(token) }
 	});
 }
 var NextScript = class extends React.Component {
@@ -80,13 +90,19 @@ var NextScript = class extends React.Component {
 	}
 	render() {
 		const { nonce, crossOrigin } = this.props;
-		return /* @__PURE__ */ jsx("span", {
+		return /* @__PURE__ */ jsx(NextScriptPlaceholder, {
 			...nonce ? { [documentAssetMarkerAttributes.scriptNonce]: nonce } : {},
-			...crossOrigin ? { [documentAssetMarkerAttributes.scriptCrossOrigin]: crossOrigin } : {},
-			dangerouslySetInnerHTML: { __html: "<!-- __NEXT_SCRIPTS__ -->" }
+			...crossOrigin ? { [documentAssetMarkerAttributes.scriptCrossOrigin]: crossOrigin } : {}
 		});
 	}
 };
+function NextScriptPlaceholder(props) {
+	const token = useDocumentPlaceholderToken();
+	return /* @__PURE__ */ jsx("span", {
+		...props,
+		dangerouslySetInnerHTML: { __html: getDocumentScriptsPlaceholder(token) }
+	});
+}
 var Document = class extends React.Component {
 	static getInitialProps(ctx) {
 		return ctx.defaultGetInitialProps(ctx);

package/dist/shims/dynamic-preload-chunks.d.ts

@@ -2,5 +2,6 @@ import React from "react";
 //#region src/shims/dynamic-preload-chunks.d.ts
 export declare function DynamicPreloadChunks(props: {
   moduleIds?: readonly string[];
+  assets: "styles" | "scripts";
 }): React.FunctionComponentElement<React.FragmentProps> | null;
 //#endregion

package/dist/shims/dynamic-preload-chunks.js

@@ -56,6 +56,7 @@ function DynamicPreloadChunks(props) {
 	for (const file of files) {
 		const assetHref = dynamicPreloadHref(file);
 		if (assetHref.endsWith(".css")) {
+			if (props.assets !== "styles") continue;
 			const href = appendAssetDeploymentIdQuery(assetHref);
 			if (initialStylesheetHrefs?.has(href)) continue;
 			preloadLinks.push(React.createElement("link", {
@@ -68,15 +69,18 @@ function DynamicPreloadChunks(props) {
 			}));
 			continue;
 		}
-		if (assetHref.endsWith(".js")) preloadLinks.push(React.createElement("link", {
-			key: assetHref,
-			rel: "modulepreload",
-			href: assetHref,
-			as: "script",
-			crossOrigin,
-			fetchPriority: "low",
-			nonce
-		}));
+		if (assetHref.endsWith(".js")) {
+			if (props.assets !== "scripts") continue;
+			preloadLinks.push(React.createElement("link", {
+				key: assetHref,
+				rel: "modulepreload",
+				href: assetHref,
+				as: "script",
+				crossOrigin,
+				fetchPriority: "low",
+				nonce
+			}));
+		}
 	}
 	return preloadLinks.length > 0 ? React.createElement(React.Fragment, null, ...preloadLinks) : null;
 }

package/dist/shims/dynamic.d.ts

@@ -4,7 +4,7 @@ import { DynamicOptions, DynamicOptionsLoadingProps, LoadableComponent, Loadable
 type DynamicInput<P> = DynamicOptions<P> | Loader<P>;
 /**
  * Retained for the Pages Router render pipeline, which calls this before
- * rendering. Dynamic imports now use React.lazy + Suspense, so there is no
+ * rendering. Dynamic imports now use React.lazy, so there is no
  * separate preload work to await.
  */
 export declare function flushPreloads(): Promise<void[]>;

package/dist/shims/dynamic.js

@@ -1,19 +1,22 @@
+import { AppRouterTreeContext } from "./app-router-tree-context.js";
 import { DynamicPreloadChunks } from "./dynamic-preload-chunks.js";
 import React from "react";
 //#region src/shims/dynamic.ts
 /**
 * next/dynamic shim
 *
-* SSR-safe dynamic imports. On the server, uses React.lazy + Suspense so that
+* SSR-safe dynamic imports. On the server, uses React.lazy so that
 * renderToReadableStream suspends until the dynamically-imported component is
-* available. On the client, also uses React.lazy for code splitting.
+* available. On the client, also uses React.lazy for code splitting. As in
+* the Next.js App Router, a Suspense boundary is added only for `ssr: false`
+* or an explicit `loading` component. Other trees (Pages Router) keep it.
 *
 * Works in RSC, SSR, and client environments:
-* - RSC: Uses React.lazy + Suspense (available in React 19.x react-server).
+* - RSC: Uses React.lazy (available in React 19.x react-server).
 *   Falls back to async component pattern if a future React version
 *   strips lazy from react-server.
-* - SSR: React.lazy + Suspense (renderToReadableStream suspends)
-* - Client: React.lazy + Suspense (standard code splitting)
+* - SSR: React.lazy (renderToReadableStream suspends)
+* - Client: React.lazy (standard code splitting)
 *
 * Supports:
 * - dynamic(import('./Component'))
@@ -115,8 +118,55 @@ function getDynamicErrorBoundary() {
 }
 const isServer = typeof window === "undefined";
 /**
+* Whether this dynamic() renders in an App Router tree. RSC renders the App
+* Router only, and react-server has no context support. On the server, the
+* App Router SSR entry marks its tree; in the browser, App Router documents
+* set `window.next.appDir` before anything renders, which also covers
+* separate client roots (e.g. a modal rendered with createRoot). Everything
+* else (Pages Router pages, `pages/_document`, ad-hoc react-dom/server
+* renders) keeps the boundary, since Pages next/dynamic is react-loadable,
+* which never suspends.
+*/
+function useIsAppRouterTree() {
+	if (!isServer) return window.next?.appDir === true;
+	return AppRouterTreeContext ? React.use(AppRouterTreeContext) : true;
+}
+/**
+* The element tree around an SSR-enabled dynamic() component. The client
+* renders empty slots where the server renders the preload chunks, so both
+* sides render the same shape and useId values inside the dynamic component
+* match on hydration.
+*
+* Match Next.js App Router Loadable: the component only gets a Suspense
+* boundary when it has a `loading` component. Without one, the lazy component
+* suspends up to the nearest parent boundary, so the server shell waits for
+* the import instead of flushing an empty boundary and streaming the
+* component in after first paint. Other trees always get the boundary.
+*
+* React hoists the preload links out of place, but a hoisted <link> right
+* after a text node leaves a `<!-- -->` separator behind. Next.js avoids it by
+* hinting scripts with ReactDOM.preload(), which renders nothing. vinext
+* renders real modulepreload links (preloadModule() drops the nonce and
+* fetchPriority), so they go where text rarely precedes them: first inside the
+* boundary, or after the content when there is no boundary (a component whose
+* output ends in text still gets a separator after it). Stylesheets stay
+* before the boundary: a precedence stylesheet inside it makes React outline
+* the boundary even when its content is already resolved, and rendering them
+* ahead of the content keeps their nonce when the content links the same CSS.
+* A dynamic component with CSS right after text therefore still gets the
+* separator.
+*/
+function createDynamicBoundary(fallback, content, preloadModuleIds, hasBoundary) {
+	const preloadChunks = (assets) => isServer ? React.createElement(DynamicPreloadChunks, {
+		moduleIds: preloadModuleIds,
+		assets
+	}) : null;
+	if (!hasBoundary) return React.createElement(React.Fragment, null, preloadChunks("styles"), content, preloadChunks("scripts"));
+	return React.createElement(React.Fragment, null, preloadChunks("styles"), React.createElement(React.Suspense, { fallback }, preloadChunks("scripts"), content));
+}
+/**
 * Retained for the Pages Router render pipeline, which calls this before
-* rendering. Dynamic imports now use React.lazy + Suspense, so there is no
+* rendering. Dynamic imports now use React.lazy, so there is no
 * separate preload work to await.
 */
 function flushPreloads() {
@@ -170,6 +220,7 @@ function dynamic(dynamicInput, options) {
 		}
 		const LazyServer = createLazyComponent(loader);
 		const ServerDynamic = (props) => {
+			const isAppRouterTree = useIsAppRouterTree();
 			const fallback = LoadingComponent ? React.createElement(LoadingComponent, createDynamicLoadingProps()) : null;
 			const lazyElement = createElementWithProps(LazyServer, props);
 			let content = lazyElement;
@@ -181,7 +232,7 @@ function dynamic(dynamicInput, options) {
 					resetKey: 0
 				}, lazyElement);
 			}
-			return React.createElement(React.Fragment, null, React.createElement(DynamicPreloadChunks, { moduleIds: preloadModuleIds }), React.createElement(React.Suspense, { fallback }, content));
+			return createDynamicBoundary(fallback, content, preloadModuleIds, LoadingComponent != null || !isAppRouterTree);
 		};
 		ServerDynamic.displayName = "DynamicServer";
 		return ServerDynamic;
@@ -189,6 +240,7 @@ function dynamic(dynamicInput, options) {
 	const InitialLazyComponent = createLazyComponent(loader);
 	const ClientDynamic = (props) => {
 		const { LazyComponent, retry, retryKey } = useRetryableLazyComponent(loader, InitialLazyComponent);
+		const isAppRouterTree = useIsAppRouterTree();
 		const fallback = LoadingComponent ? React.createElement(LoadingComponent, createDynamicLoadingProps({ retry })) : null;
 		const lazyElement = createElementWithProps(LazyComponent, props);
 		let content = lazyElement;
@@ -200,7 +252,7 @@ function dynamic(dynamicInput, options) {
 				resetKey: retryKey
 			}, lazyElement);
 		}
-		return React.createElement(React.Suspense, { fallback }, content);
+		return createDynamicBoundary(fallback, content, preloadModuleIds, LoadingComponent != null || !isAppRouterTree);
 	};
 	ClientDynamic.displayName = "DynamicClient";
 	return ClientDynamic;

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

@@ -2,4 +2,11 @@ import { AppRouterInstance } from "./internal/app-router-context.js";
 //#region src/shims/error-boundary-navigation.d.ts
 export declare function useErrorBoundaryPathname(): string;
 export declare function useErrorBoundaryRouter(): AppRouterInstance;
+/**
+ * Whether following a redirect() would refetch the URL the browser is at,
+ * which renders the same redirect again. As in the navigation planner, only the
+ * exact URL refreshes the page; any hash change, including removing the
+ * current hash, only scrolls.
+ */
+export declare function isRedirectToCurrentUrl(redirect: string): boolean;
 //#endregion

package/dist/shims/error-boundary-navigation.js

@@ -1,6 +1,7 @@
 import { stripBasePath } from "../utils/base-path.js";
 import { markPprFallbackShellDynamicBoundary } from "./ppr-fallback-shell.js";
 import { AppRouterContext } from "./internal/app-router-context.js";
+import { toCanonicalBrowserNavigationHref, toSameOriginAppPath } from "./url-utils.js";
 import { getNavigationContext } from "./navigation-context-state.js";
 import "./navigation-server.js";
 import * as React$1 from "react";
@@ -8,6 +9,7 @@ import * as React$1 from "react";
 const CLIENT_NAVIGATION_STATE_KEY = Symbol.for("vinext.clientNavigationState");
 const CLIENT_NAVIGATION_RENDER_CONTEXT_KEY = Symbol.for("vinext.clientNavigationRenderContext");
 const BASE_PATH = process.env.__NEXT_ROUTER_BASEPATH ?? "";
+const TRAILING_SLASH = process.env.__VINEXT_TRAILING_SLASH === "true";
 function getClientNavigationState() {
 	return globalThis[CLIENT_NAVIGATION_STATE_KEY];
 }
@@ -40,5 +42,21 @@ function useErrorBoundaryRouter() {
 	if (router === null) throw new Error("invariant expected app router to be mounted");
 	return router;
 }
+/**
+* Whether following a redirect() would refetch the URL the browser is at,
+* which renders the same redirect again. As in the navigation planner, only the
+* exact URL refreshes the page; any hash change, including removing the
+* current hash, only scrolls.
+*/
+function isRedirectToCurrentUrl(redirect) {
+	if (typeof window === "undefined") return false;
+	try {
+		const current = new URL(window.location.href);
+		const target = new URL(toCanonicalBrowserNavigationHref(toSameOriginAppPath(redirect, BASE_PATH) ?? redirect, current.href, BASE_PATH, TRAILING_SLASH), current.href);
+		return target.hash === current.hash && target.origin === current.origin && target.pathname === current.pathname && target.search === current.search;
+	} catch {
+		return false;
+	}
+}
 //#endregion
-export { useErrorBoundaryPathname, useErrorBoundaryRouter };
+export { isRedirectToCurrentUrl, useErrorBoundaryPathname, useErrorBoundaryRouter };

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