vinext 1.1.0 → 1.2.0

package/dist/shims/app-router-tree-context.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+//#region src/shims/app-router-tree-context.d.ts
+export declare const AppRouterTreeContext: React.Context<boolean> | null;
+export declare function withAppRouterTree(children: React.ReactElement): React.ReactElement;
+//#endregion

package/dist/shims/app-router-tree-context.js

@@ -0,0 +1,27 @@
+import React from "react";
+//#region src/shims/app-router-tree-context.ts
+/**
+* Marks an App Router server render tree. The App Router SSR entry provides
+* `true` at its root; every other server tree (Pages Router pages,
+* `pages/_document`, ad-hoc react-dom/server renders) reads the `false`
+* default. Lets shared shims such as next/dynamic apply App Router semantics
+* only where Next.js does. In the browser, `window.next.appDir` (installed
+* when the App Router browser entry loads) identifies App Router documents.
+*
+* Stored on a global symbol so duplicate module instances share one context,
+* and null in react-server, which has no createContext (RSC is App Router
+* only).
+*/
+const APP_ROUTER_TREE_CONTEXT_KEY = Symbol.for("vinext.appRouterTreeContext");
+function getAppRouterTreeContext() {
+	if (typeof React.createContext !== "function") return null;
+	const globalState = globalThis;
+	globalState[APP_ROUTER_TREE_CONTEXT_KEY] ??= React.createContext(false);
+	return globalState[APP_ROUTER_TREE_CONTEXT_KEY];
+}
+const AppRouterTreeContext = getAppRouterTreeContext();
+function withAppRouterTree(children) {
+	return AppRouterTreeContext ? React.createElement(AppRouterTreeContext.Provider, { value: true }, children) : children;
+}
+//#endregion
+export { AppRouterTreeContext, withAppRouterTree };

package/dist/shims/cache-callable-runtime.d.ts

@@ -6,8 +6,10 @@ type CacheCaptureEnvelope = {
   type: typeof CACHE_CAPTURE_TYPE;
   encrypted: Promise<string>;
 };
-export declare function encryptCacheCaptures(captures: unknown[]): CacheCaptureEnvelope;
-export declare function registerCachedFunction<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, id: string, variant: string, options: RegisterCachedFunctionOptions): (...args: TArgs) => Promise<TResult>;
+export declare function encryptCacheCaptures(referenceId: string, captures: unknown[]): CacheCaptureEnvelope;
+export declare function registerCachedFunction<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, id: string, variant: string, { captureCount, ...options }: RegisterCachedFunctionOptions & {
+  captureCount?: number;
+}): (...args: TArgs) => Promise<TResult>;
 /** Replay the persisted payload without re-reading or re-encoding caller objects. */
 export declare function invokeCacheFunction(invocation: VinextCacheFunctionInvocation, loadServerAction: (id: string) => Promise<unknown>): Promise<void>;
 //#endregion

package/dist/shims/cache-callable-runtime.js

@@ -14,14 +14,14 @@ async function decryptArguments(encrypted) {
 	if (value?.version !== 1) throw new Error("Invalid cache function arguments");
 	return value;
 }
-function encryptCacheCaptures(captures) {
-	return memoizedCaptureEnvelope(...captures);
+function encryptCacheCaptures(referenceId, captures) {
+	return memoizedCaptureEnvelope(referenceId, ...captures);
 }
-const memoizedCaptureEnvelope = memoizeInCacheScope((...captures) => ({
+const memoizedCaptureEnvelope = memoizeInCacheScope((referenceId, ...captures) => ({
 	type: CACHE_CAPTURE_TYPE,
-	encrypted: encryptCaptures(captures)
+	encrypted: encryptCaptures(referenceId, captures)
 }));
-async function encryptCaptures(captures) {
+async function encryptCaptures(referenceId, captures) {
 	const files = new FormData();
 	let nextFileId = 0;
 	const temporaryReferences = new class extends WeakMap {
@@ -39,26 +39,35 @@ async function encryptCaptures(captures) {
 	const bytes = await new Response(stream).arrayBuffer();
 	return encryptActionBoundArgs(JSON.stringify({
 		version: 1,
+		referenceId,
 		result: Buffer.from(bytes).toString("base64"),
 		files: await snapshotFlightReply(files)
 	}));
 }
-async function decryptCacheCaptures(value) {
-	if (typeof value !== "object" || value === null || !("type" in value) || value.type !== CACHE_CAPTURE_TYPE || !("encrypted" in value)) return;
+async function decryptCacheCaptures(value, referenceId, captureCount) {
+	if (typeof value !== "object" || value === null || !("type" in value) || value.type !== CACHE_CAPTURE_TYPE || !("encrypted" in value)) throw new Error("Invalid cache capture arguments");
 	const encrypted = value.encrypted;
-	if (typeof encrypted !== "string" && !(typeof encrypted === "object" && encrypted !== null && "then" in encrypted && typeof encrypted.then === "function")) return;
+	if (typeof encrypted !== "string" && !(typeof encrypted === "object" && encrypted !== null && "then" in encrypted && typeof encrypted.then === "function")) throw new Error("Invalid cache capture arguments");
 	const serialized = await decryptActionBoundArgs(Promise.resolve(encrypted));
 	if (typeof serialized !== "string") throw new Error("Invalid cache capture arguments");
 	const payload = JSON.parse(serialized);
-	if (payload.version !== 1) throw new Error("Invalid cache capture arguments");
+	if (payload.version !== 1 || payload.referenceId !== referenceId) throw new Error("Invalid cache capture arguments");
 	const files = restoreFlightReply(payload.files);
 	if (typeof files === "string") throw new Error("Invalid cache capture files");
-	return await createFromReadableStream(new Response(Buffer.from(payload.result, "base64")).body, { temporaryReferences: new Map([...files].map(([id, file]) => [`$${id}`, file])) }, { preserveServerReferences: true });
+	const captures = await createFromReadableStream(new Response(Buffer.from(payload.result, "base64")).body, { temporaryReferences: new Map([...files].map(([id, file]) => [`$${id}`, file])) }, { preserveServerReferences: true });
+	if (!Array.isArray(captures) || captures.length !== captureCount) throw new Error("Invalid cache capture arguments");
+	return captures;
 }
-function registerCachedFunction(fn, id, variant, options) {
+function registerCachedFunction(fn, id, variant, { captureCount, ...options }) {
+	let decryptCaptures;
+	if (captureCount !== void 0) {
+		const referenceId = options.serverReferenceId;
+		if (referenceId === void 0) throw new Error(`Cache function ${id} has captures but no server reference`);
+		decryptCaptures = (value) => decryptCacheCaptures(value, referenceId, captureCount);
+	}
 	return registerCachedFunction$1(fn, id, variant, {
 		...options,
-		decryptCaptures: decryptCacheCaptures,
+		...decryptCaptures ? { decryptCaptures } : {},
 		encodeInvocation: encryptArguments
 	});
 }

package/dist/shims/cache-handler.js

@@ -8,7 +8,6 @@ var NoOpCacheHandler = class {
 	async revalidateTag(_tags, _durations) {}
 };
 const DEFAULT_MEMORY_CACHE_MAX_SIZE = 52428800;
-const MAX_REVALIDATED_TAG_ENTRIES = 1e4;
 function estimateStringMapSize(map) {
 	if (!map) return 0;
 	let size = 0;
@@ -151,14 +150,7 @@ var MemoryCacheHandler = class {
 	async revalidateTag(tags) {
 		const tagList = Array.isArray(tags) ? tags : [tags];
 		const now = Date.now();
-		for (const tag of tagList) {
-			this.tagRevalidatedAt.set(tag, now);
-			while (this.tagRevalidatedAt.size > MAX_REVALIDATED_TAG_ENTRIES) {
-				const oldest = this.tagRevalidatedAt.keys().next().value;
-				if (oldest === void 0) break;
-				this.tagRevalidatedAt.delete(oldest);
-			}
-		}
+		for (const tag of tagList) this.tagRevalidatedAt.set(tag, now);
 	}
 	resetRequestCache() {}
 };

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

@@ -77,7 +77,12 @@ export type RegisterCachedFunctionOptions = {
   acceptsSecondArgument?: boolean;
   /** Number of declared arguments supplied by the directive transform. */
   argumentCount?: number;
-  decryptCaptures?: (value: unknown) => Promise<unknown[] | undefined>;
+  /**
+   * Set only for an inline function that closes over values. It decrypts the
+   * capture envelope bound ahead of the call arguments and must reject any
+   * other first argument.
+   */
+  decryptCaptures?: (value: unknown) => Promise<unknown[]>;
   encodeInvocation?: (args: CacheFlightArguments) => Promise<string>;
   serverReferenceId?: string;
 };

package/dist/shims/cache-runtime.js

@@ -4,13 +4,14 @@ import { VINEXT_RSC_MARKER_HEADER } from "../server/headers.js";
 import { workUnitAsyncStorage } from "./internal/work-unit-async-storage.js";
 import { isRouteCacheabilityProbe, recordRouteCacheabilityProbeBailout } from "./cacheability-classification.js";
 import { getDataCacheHandler } from "./cache-handler.js";
+import { addCollectedRequestTags, getCurrentFetchSoftTags, runWithDetachedFetchObservations } from "./fetch-cache-state.js";
 import { suppressHangingPromiseAbortRejections } from "./internal/make-hanging-promise.js";
 import { createPprFallbackShellSuspensePromise, trackPprFallbackShellCacheTask } from "./ppr-fallback-shell.js";
 import { markDynamicUsage, throwIfInsideCacheScope } from "./internal/headers-state.js";
 import { isDraftModeEnabled } from "./headers.js";
 import { _registerCacheContextAccessor } from "./internal/cache-context-accessor.js";
 import { _hasPendingRevalidatedTag, _setRequestScopedCacheLife, cacheLifeProfiles, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
-import { addCollectedRequestTags, getCurrentFetchSoftTags, runWithDetachedFetchObservations } from "./fetch-cache.js";
+import "./fetch-cache.js";
 import { hasUseCacheLayoutMarker, hasUseCachePageMarker, isUseCacheFunctionReference, withoutUseCacheSegmentMarker } from "./internal/app-page-props-cache-key.js";
 import { getFallbackParamsSnapshot, makeThenableParams, restoreThenableParams } from "./thenable-params.js";
 import { getCurrentRootParams } from "./root-params.js";

package/dist/shims/cache.d.ts

@@ -137,8 +137,8 @@ type UnstableCacheOptions = {
 /**
  * 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.
  */
 export declare function unstable_cache<T extends (...args: any[]) => Promise<any>>(fn: T, keyParts?: string[], options?: UnstableCacheOptions): T;
 //#endregion

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, runWithDetachedCacheObservations, shouldServeStaleUnstableCacheEntry } from "./cache-request-state.js";
-import { addCollectedRequestTags, getCurrentFetchSoftTags, runWithDetachedFetchObservations } from "./fetch-cache.js";
 //#region src/shims/cache.ts
 /**
 * next/cache shim
@@ -323,6 +324,7 @@ const UNSTABLE_CACHE_KEY_PREFIX = "unstable_cache:v2";
 */
 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 });
 }
@@ -348,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];
@@ -371,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: {
@@ -390,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",
@@ -424,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;
@@ -432,7 +459,7 @@ 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;
 }

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[]>;