vinext 1.0.0-beta.8 → 1.0.0

package/dist/shims/headers.js

@@ -1,9 +1,9 @@
 import { getOrCreateAls } from "./internal/als-registry.js";
-import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
-import { parseEdgeRequestCookieHeader } from "../utils/parse-cookie.js";
+import { ensureRenderDynamicLatch, getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
 import { MIDDLEWARE_SET_COOKIE_HEADER } from "../utils/protocol-headers.js";
-import { FLIGHT_HEADERS, NEXT_HTML_REQUEST_ID_HEADER, NEXT_REQUEST_ID_HEADER } from "../server/headers.js";
 import { buildRequestHeadersFromMiddlewareResponse } from "../utils/middleware-request-headers.js";
+import { parseEdgeRequestCookieHeader } from "../utils/parse-cookie.js";
+import { FLIGHT_HEADERS, NEXT_HTML_REQUEST_ID_HEADER, NEXT_REQUEST_ID_HEADER } from "../server/headers.js";
 import { serializeSetCookie, validateCookieName } from "./internal/cookie-serialize.js";
 import { createPprFallbackShellSuspensePromise } from "./ppr-fallback-shell.js";
 //#region src/shims/headers.ts
@@ -16,12 +16,19 @@ import { createPprFallbackShellSuspensePromise } from "./ppr-fallback-shell.js";
 * In Next.js 15+, cookies() and headers() return Promises (async).
 * We support both the sync (legacy) and async patterns.
 */
+function createRenderDynamicLatch() {
+	return {
+		dynamic: false,
+		listeners: /* @__PURE__ */ new Set()
+	};
+}
 const _FALLBACK_KEY = Symbol.for("vinext.nextHeadersShim.fallback");
 const _g = globalThis;
 const _als = getOrCreateAls("vinext.nextHeadersShim.als");
 const _fallbackState = _g[_FALLBACK_KEY] ??= {
 	headersContext: null,
 	dynamicUsageDetected: false,
+	renderDynamicLatch: createRenderDynamicLatch(),
 	renderRequestApiUsage: /* @__PURE__ */ new Set(),
 	connectionProbe: null,
 	invalidDynamicUsageError: null,
@@ -113,9 +120,40 @@ function markDynamicUsage() {
 	const state = _getState();
 	if (state.headersContext?.forceStatic) return;
 	state.dynamicUsageDetected = true;
+	const latches = [ensureRenderDynamicLatch(state)];
 	forEachConnectionProbeTarget(state, (target) => {
 		target.dynamicUsageDetected = true;
+		latches.push(ensureRenderDynamicLatch(target));
 	});
+	for (const latch of latches) latchRenderDynamic(latch);
+}
+function latchRenderDynamic(latch) {
+	if (latch.dynamic) return;
+	latch.dynamic = true;
+	const listeners = [...latch.listeners];
+	latch.listeners.clear();
+	for (const listener of listeners) try {
+		listener();
+	} catch (error) {
+		console.error(error);
+	}
+}
+/** Whether the current render has used a dynamic API at any point so far. */
+function isRenderDynamicLatched() {
+	return ensureRenderDynamicLatch(_getState()).dynamic;
+}
+/**
+* Call `listener` once when the current render first uses a dynamic API.
+* Returns an unsubscribe function. The listener never runs if the render is
+* already latched; check `isRenderDynamicLatched()` first.
+*/
+function onRenderDynamicLatched(listener) {
+	const latch = ensureRenderDynamicLatch(_getState());
+	if (latch.dynamic) return () => {};
+	latch.listeners.add(listener);
+	return () => {
+		latch.listeners.delete(listener);
+	};
 }
 function forEachConnectionProbeTarget(state, visit) {
 	let target = state.connectionProbe?.dynamicUsageTarget ?? null;
@@ -154,8 +192,10 @@ async function runWithIsolatedDynamicUsage(fn) {
 			return runInChildState(childState);
 		});
 	}
+	const parentState = _getState();
 	const childState = {
-		..._getState(),
+		...parentState,
+		renderDynamicLatch: ensureRenderDynamicLatch(parentState),
 		dynamicUsageDetected: false
 	};
 	return await _als.run(childState, () => runInChildState(childState));
@@ -211,6 +251,7 @@ async function runWithConnectionProbe(fn) {
 	}
 	const childState = {
 		...parentState,
+		renderDynamicLatch: ensureRenderDynamicLatch(parentState),
 		connectionProbe: probe
 	};
 	return await _als.run(childState, () => runInChildState(childState));
@@ -234,15 +275,15 @@ function consumeRenderRequestApiUsage() {
 const _USE_CACHE_ALS_KEY = Symbol.for("vinext.cacheRuntime.contextAls");
 /** Symbol used by cache.ts to store the unstable_cache ALS on globalThis */
 const _UNSTABLE_CACHE_ALS_KEY = Symbol.for("vinext.unstableCache.als");
-function _getGlobalCacheScopeStorage(key) {
+function _getGlobalCacheScopeStore(key) {
 	const value = Reflect.get(globalThis, key);
 	if (!value || typeof value !== "object") return null;
 	const getStore = Reflect.get(value, "getStore");
 	if (typeof getStore !== "function") return null;
-	return { getStore: () => getStore.call(value) };
+	return getStore.call(value);
 }
 function _getUseCacheGuardContext() {
-	const store = _getGlobalCacheScopeStorage(_USE_CACHE_ALS_KEY)?.getStore();
+	const store = _getGlobalCacheScopeStore(_USE_CACHE_ALS_KEY);
 	if (!store || typeof store !== "object") return null;
 	return store;
 }
@@ -251,7 +292,11 @@ function _isInsidePublicUseCache() {
 	return ctx !== null && ctx.variant !== "private";
 }
 function _isInsideUnstableCache() {
-	return _getGlobalCacheScopeStorage(_UNSTABLE_CACHE_ALS_KEY)?.getStore() === true;
+	return _getGlobalCacheScopeStore(_UNSTABLE_CACHE_ALS_KEY) === true;
+}
+/** Whether work is executing inside a cache boundary that owns its reuse. */
+function isInsideAnyCacheScope() {
+	return _getUseCacheGuardContext() !== null || _isInsideUnstableCache();
 }
 /**
 * Throw if the current execution is inside a "use cache" or unstable_cache()
@@ -350,11 +395,54 @@ function getHeadersAccessPhase() {
 function getHeadersContext() {
 	return _getState().headersContext;
 }
+/** Serialize the effective request-cookie view, including middleware Set-Cookie overlays. */
+function getEffectiveRequestCookieHeader() {
+	const context = getHeadersContext();
+	if (!context || context.cookies.size === 0) return null;
+	return [...context.cookies].map(([name, value]) => `${name}=${encodeURIComponent(value)}`).join("; ");
+}
+function hasEffectiveRequestCookieChanges(cookieHeader) {
+	const effective = getHeadersContext()?.cookies;
+	if (!effective) return false;
+	const original = parseEdgeRequestCookieHeader(cookieHeader ?? "");
+	if (effective.size !== original.size) return true;
+	for (const [name, value] of effective) if (original.get(name) !== value) return true;
+	return false;
+}
+/**
+* Replace only the request-cookie view for the active request scope.
+*
+* Middleware Set-Cookie mutations are visible through `cookies()` during the
+* same request in Next.js, but they do not rewrite the raw `Cookie` value
+* returned by `headers()`. The staged App renderer uses this seam to restore
+* that split view without changing the request Headers object.
+*/
+function applyEffectiveRequestCookieHeader(cookieHeader) {
+	const context = _getState().headersContext;
+	if (!context) return;
+	rebuildCookiesFromHeader(context, cookieHeader);
+	context.readonlyCookies = void 0;
+	context.mutableCookies = void 0;
+}
+/** Restore a middleware draft-mode transition inside a staged render scope. */
+function restoreDraftModeTransition(cookieHeader) {
+	const state = _getState();
+	const context = state.headersContext;
+	if (!context) return;
+	const entry = setCookieNameValue(cookieHeader);
+	if (!entry || entry.name !== DRAFT_MODE_COOKIE) return;
+	context.cookies.set(entry.name, entry.value);
+	context.readonlyCookies = void 0;
+	context.mutableCookies = void 0;
+	context.draftModeEnabled = entry.value === validateDraftModeSecret(context.draftModeSecret ?? "");
+	state.draftModeCookieHeader = cookieHeader;
+}
 function setHeadersContext(ctx) {
 	const state = _getState();
 	if (ctx !== null) {
 		state.headersContext = ctx;
 		state.dynamicUsageDetected = false;
+		state.renderDynamicLatch = createRenderDynamicLatch();
 		state.renderRequestApiUsage = /* @__PURE__ */ new Set();
 		state.pendingSetCookies = [];
 		state.draftModeCookieHeader = null;
@@ -368,6 +456,7 @@ function runWithHeadersContext(ctx, fn) {
 	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((uCtx) => {
 		uCtx.headersContext = ctx;
 		uCtx.dynamicUsageDetected = false;
+		uCtx.renderDynamicLatch = createRenderDynamicLatch();
 		uCtx.renderRequestApiUsage = /* @__PURE__ */ new Set();
 		uCtx.connectionProbe = null;
 		uCtx.pendingSetCookies = [];
@@ -377,6 +466,7 @@ function runWithHeadersContext(ctx, fn) {
 	const state = {
 		headersContext: ctx,
 		dynamicUsageDetected: false,
+		renderDynamicLatch: createRenderDynamicLatch(),
 		renderRequestApiUsage: /* @__PURE__ */ new Set(),
 		connectionProbe: null,
 		invalidDynamicUsageError: null,
@@ -586,7 +676,8 @@ function headersContextFromRequest(request, options) {
 	let _cookies = null;
 	function getCookies() {
 		if (_cookies) return _cookies;
-		_cookies = parseEdgeRequestCookieHeader(headersProxy.get("cookie") || "");
+		const cookieHeader = headersProxy.get("cookie") || "";
+		_cookies = parseEdgeRequestCookieHeader(cookieHeader);
 		return _cookies;
 	}
 	return {
@@ -887,4 +978,4 @@ function serializeMutableCookie(cookie) {
 	});
 }
 //#endregion
-export { applyMiddlewareRequestHeaders, consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage, cookies, draftMode, getActiveDraftModeState, getAndClearPendingCookies, getDraftModeCookieHeader, getHeadersAccessPhase, getHeadersContext, headers, headersContextFromRequest, isDraftModeEnabled, isDraftModeRequest, markDynamicUsage, markRenderRequestApiUsage, peekDynamicUsage, peekRenderRequestApiUsage, runWithConnectionProbe, runWithHeadersContext, runWithIsolatedDynamicUsage, setHeadersAccessPhase, setHeadersContext, suspendConnectionProbe, throwIfInsideCacheScope, throwIfStaticGenerationAccessError };
+export { applyEffectiveRequestCookieHeader, applyMiddlewareRequestHeaders, consumeDynamicUsage, consumeInvalidDynamicUsageError, consumeRenderRequestApiUsage, cookies, createRenderDynamicLatch, draftMode, getActiveDraftModeState, getAndClearPendingCookies, getDraftModeCookieHeader, getEffectiveRequestCookieHeader, getHeadersAccessPhase, getHeadersContext, hasEffectiveRequestCookieChanges, headers, headersContextFromRequest, isDraftModeEnabled, isDraftModeRequest, isInsideAnyCacheScope, isRenderDynamicLatched, markDynamicUsage, markRenderRequestApiUsage, onRenderDynamicLatched, peekDynamicUsage, peekRenderRequestApiUsage, restoreDraftModeTransition, runWithConnectionProbe, runWithHeadersContext, runWithIsolatedDynamicUsage, setHeadersAccessPhase, setHeadersContext, suspendConnectionProbe, throwIfInsideCacheScope, throwIfStaticGenerationAccessError };

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

@@ -1,6 +1,6 @@
 import { DomainLocale } from "../utils/domain-locale.js";
 //#region src/shims/i18n-context.d.ts
-type I18nContext = {
+export type I18nContext = {
   locale?: string;
   locales?: string[];
   defaultLocale?: string;
@@ -11,11 +11,10 @@ type I18nContext = {
  * Register ALS-backed accessors. Called by i18n-state.ts on import.
  * @internal
  */
-declare function _registerI18nStateAccessors(accessors: {
+export declare function _registerI18nStateAccessors(accessors: {
   getI18nContext: () => I18nContext | null;
   setI18nContext: (ctx: I18nContext | null) => void;
 }): void;
-declare function getI18nContext(): I18nContext | null;
-declare function setI18nContext(ctx: I18nContext | null): void;
-//#endregion
-export { I18nContext, _registerI18nStateAccessors, getI18nContext, setI18nContext };
+export declare function getI18nContext(): I18nContext | null;
+export declare function setI18nContext(ctx: I18nContext | null): void;
+//#endregion

package/dist/shims/i18n-state.d.ts

@@ -1,13 +1,12 @@
 import { I18nContext } from "./i18n-context.js";
 //#region src/shims/i18n-state.d.ts
-type I18nState = {
+export type I18nState = {
   i18nContext: I18nContext | null;
 };
 /**
  * Run a function within an i18n state ALS scope.
  * Ensures per-request isolation for i18n context on concurrent runtimes.
  */
-declare function runWithI18nState<T>(fn: () => Promise<T>): Promise<T>;
-declare function runWithI18nState<T>(fn: () => T | Promise<T>): T | Promise<T>;
-//#endregion
-export { I18nState, runWithI18nState };
+export declare function runWithI18nState<T>(fn: () => Promise<T>): Promise<T>;
+export declare function runWithI18nState<T>(fn: () => T | Promise<T>): T | Promise<T>;
+//#endregion

package/dist/shims/image-config.d.ts

@@ -12,7 +12,7 @@
  * - `**` matches any number of segments
  * - protocol, port, and search are matched exactly when specified
  */
-type RemotePattern = {
+export type RemotePattern = {
   protocol?: string;
   hostname: string;
   port?: string;
@@ -23,11 +23,11 @@ type RemotePattern = {
  * Check whether a URL matches a single remote pattern.
  * Follows the same semantics as Next.js's matchRemotePattern().
  */
-declare function matchRemotePattern(pattern: RemotePattern, url: URL): boolean;
+export declare function matchRemotePattern(pattern: RemotePattern, url: URL): boolean;
 /**
  * Check whether a URL matches any configured remote pattern or legacy domain.
  */
-declare function hasRemoteMatch(domains: string[], remotePatterns: RemotePattern[], url: URL): boolean;
+export declare function hasRemoteMatch(domains: string[], remotePatterns: RemotePattern[], url: URL): boolean;
 /**
  * Determine whether a string is a private (non-routable) IP address.
  * Works for IPv4 and IPv6, including bracketed and IPv4-mapped forms.
@@ -40,6 +40,5 @@ declare function hasRemoteMatch(domains: string[], remotePatterns: RemotePattern
  *
  * https://github.com/vercel/next.js/blob/canary/packages/next/src/server/is-private-ip.ts
  */
-declare function isPrivateIp(ip: string): boolean;
-//#endregion
-export { RemotePattern, hasRemoteMatch, isPrivateIp, matchRemotePattern };
+export declare function isPrivateIp(ip: string): boolean;
+//#endregion

package/dist/shims/image-config.js

@@ -59,6 +59,7 @@ function matchRemotePattern(pattern, url) {
 function hasRemoteMatch(domains, remotePatterns, url) {
 	return domains.some((domain) => url.hostname === domain) || remotePatterns.some((p) => matchRemotePattern(p, url));
 }
+const IPV4_LITERAL_CHARS_RE = /^[0-9a-fA-FxX.]+$/;
 /**
 * Determine whether a string is a private (non-routable) IP address.
 * Works for IPv4 and IPv6, including bracketed and IPv4-mapped forms.
@@ -73,6 +74,7 @@ function hasRemoteMatch(domains, remotePatterns, url) {
 */
 function isPrivateIp(ip) {
 	if (ip.startsWith("[") && ip.endsWith("]")) ip = ip.slice(1, -1);
+	if (!ip.includes(":") && !IPV4_LITERAL_CHARS_RE.test(ip)) return false;
 	try {
 		const parsed = ipaddr.parse(ip);
 		if (parsed instanceof ipaddr.IPv6 && parsed.isIPv4MappedAddress()) return parsed.toIPv4Address().range() !== "unicast";

package/dist/shims/image.d.ts

@@ -1,8 +1,8 @@
 import React from "react";
 import { ImageLoader, ImageProps as ImageProps$1, ImgProps, StaticImageData, StaticImport, StaticRequire } from "@vinext/types/next/upstream/dist/shared/lib/get-img-props";
 //#region src/shims/image.d.ts
-type ImageLoaderProps = Parameters<ImageLoader>[0];
-type ImageProps = ImageProps$1;
+export type ImageLoaderProps = Parameters<ImageLoader>[0];
+export type ImageProps = ImageProps$1;
 /**
  * Build a `/_next/image` optimization URL.
  *
@@ -10,7 +10,7 @@ type ImageProps = ImageProps$1;
  * the Images binding to resize/transcode on the fly. In dev, the Vite dev
  * server handles it as a passthrough (serves the original file).
  */
-declare function imageOptimizationUrl(src: string, width: number, quality?: number): string;
+export declare function imageOptimizationUrl(src: string, width: number, quality?: number): string;
 declare const Image: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, "alt" | "height" | "loading" | "ref" | "src" | "srcSet" | "width"> & {
   src: string | StaticImport;
   alt: string;
@@ -37,8 +37,8 @@ declare const Image: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProp
  * getImageProps — for advanced use cases (picture elements, background images).
  * Returns the props that would be passed to the underlying <img> element.
  */
-declare function getImageProps(props: ImageProps): {
+export declare function getImageProps(props: ImageProps): {
   props: ImgProps;
 };
 //#endregion
-export { type ImageLoader, ImageLoaderProps, ImageProps, type StaticImageData, type StaticRequire, Image as default, getImageProps, imageOptimizationUrl };
+export { type ImageLoader, type StaticImageData, type StaticRequire, Image as default };

package/dist/shims/image.js

@@ -453,10 +453,12 @@ const Image = forwardRef(function Image({ src: srcProp, alt, width, height, fill
 	}
 	if (isRemoteUrl(src)) {
 		const validation = validateRemoteUrl(src);
-		if (!validation.allowed) if (__isDev) console.warn(`[next/image] ${validation.reason}`);
-		else {
-			console.error(`[next/image] ${validation.reason}`);
-			return null;
+		if (!validation.allowed) {
+			if (__isDev) console.warn(`[next/image] ${validation.reason}`);
+			else {
+				console.error(`[next/image] ${validation.reason}`);
+				return null;
+			}
 		}
 		const sanitizedBlur = imgBlurDataURL ? sanitizeBlurDataURL(imgBlurDataURL) : void 0;
 		const showBlur = !blurComplete && placeholder === "blur" && sanitizedBlur;
@@ -603,10 +605,12 @@ function getImageProps(props) {
 	let blockedInProd = false;
 	if (isRemoteUrl(src)) {
 		const validation = validateRemoteUrl(src);
-		if (!validation.allowed) if (__isDev) console.warn(`[next/image] ${validation.reason}`);
-		else {
-			console.error(`[next/image] ${validation.reason}`);
-			blockedInProd = true;
+		if (!validation.allowed) {
+			if (__isDev) console.warn(`[next/image] ${validation.reason}`);
+			else {
+				console.error(`[next/image] ${validation.reason}`);
+				blockedInProd = true;
+			}
 		}
 	}
 	const imgQuality = typeof _quality === "string" ? Number(_quality) : _quality ?? 75;

package/dist/shims/internal/als-registry.d.ts

@@ -8,7 +8,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
  * @param key - String key fed to `Symbol.for(...)`. By convention vinext
  *   shims use a dotted namespace such as `"vinext.cache.als"`.
  */
-declare function getOrCreateAls<T>(key: string): AsyncLocalStorage<T>;
+export declare function getOrCreateAls<T>(key: string): AsyncLocalStorage<T>;
 /**
  * Enrol an ALS that is *not* created through `getOrCreateAls` into the
  * scope-exit set. For stores that must stay module-local for identity reasons
@@ -19,7 +19,7 @@ declare function getOrCreateAls<T>(key: string): AsyncLocalStorage<T>;
  * keeps importing nothing but `node:async_hooks` and stays safe to evaluate in
  * client bundles where that resolves to a constructor-less stub.
  */
-declare function registerAlsForScopeExit(als: AsyncLocalStorage<never>): void;
+export declare function registerAlsForScopeExit(als: AsyncLocalStorage<never>): void;
 /**
  * Run `fn` — and every async continuation it starts — outside every
  * request-scoped AsyncLocalStorage vinext installs, so the callback observes no
@@ -38,6 +38,5 @@ declare function registerAlsForScopeExit(als: AsyncLocalStorage<never>): void;
  * the unified store is absent, so a partial exit would enable that path rather
  * than close it.
  */
-declare function runOutsideRequestScopes<T>(fn: () => T): T;
-//#endregion
-export { getOrCreateAls, registerAlsForScopeExit, runOutsideRequestScopes };
+export declare function runOutsideRequestScopes<T>(fn: () => T): T;
+//#endregion

package/dist/shims/internal/api-utils.d.ts

@@ -4,11 +4,10 @@
  *
  * Used by: @clerk/nextjs (type-only import of NextApiRequestCookies).
  */
-type NextApiRequestCookies = Partial<{
+export type NextApiRequestCookies = Partial<{
   [key: string]: string;
 }>;
-type NextApiRequestQuery = Partial<{
+export type NextApiRequestQuery = Partial<{
   [key: string]: string | string[];
 }>;
-//#endregion
-export { NextApiRequestCookies, NextApiRequestQuery };
+//#endregion

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

@@ -1,5 +1,33 @@
 //#region src/shims/internal/app-page-props-cache-key.d.ts
-declare function markAppPagePropsForUseCache<T extends object>(props: T): T;
-declare function isMarkedAppPagePropsObject(value: object): boolean;
-//#endregion
-export { isMarkedAppPagePropsObject, markAppPagePropsForUseCache };
+/**
+ * Enumerable page marker, matching Next.js's `$$isPage` prop. It must be an
+ * ordinary string key: React's createElement drops symbol and non-enumerable
+ * 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
+ * server-reference `bind` copies `$$typeof`/`$$id` to the bound function but
+ * not vinext's own marker symbol.
+ */
+export declare function isUseCacheFunctionReference(fn: unknown): boolean;
+/**
+ * Add Next.js's `$$isPage` marker when `fn` is a `"use cache"` function
+ * invoked as a page component or as a page's generateMetadata/generateViewport
+ * (create-component-tree.tsx, resolve-metadata.ts `createSegmentProps`). The
+ * cache wrapper reads and removes it, so page semantics follow the invocation
+ * even when the cached function is defined in (or re-exported from) another
+ * module, or bound.
+ */
+export declare function withUseCachePageMarker<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
+ * reading the marker through a thenable params/searchParams proxy would be
+ * observed as a param access.
+ */
+export declare function hasUseCachePageMarker(value: unknown): value is Record<string, unknown>;
+//#endregion

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

@@ -1,5 +1,20 @@
 //#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");
+/**
+* Server reference ids of transformed cache functions end in the export name
+* the use-cache transform assigns (`secureExportName` in
+* plugins/use-cache-callable.ts): `$$vinext_cache_` plus an HMAC-SHA256 hex
+* digest. `"use server"` actions keep their own export names.
+*/
+const USE_CACHE_SERVER_REFERENCE_ID_RE = /#\$\$vinext_cache_[0-9a-f]{64}$/;
+/**
+* Enumerable page marker, matching Next.js's `$$isPage` prop. It must be an
+* ordinary string key: React's createElement drops symbol and non-enumerable
+* 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,
@@ -12,5 +27,42 @@ function markAppPagePropsForUseCache(props) {
 function isMarkedAppPagePropsObject(value) {
 	return Reflect.get(value, APP_PAGE_PROPS_CACHE_KEY_MARKER) === true;
 }
+/**
+* Whether `fn` is a transformed `"use cache"` function, including a bound
+* one. Like Next.js's `isUseCacheFunction`, this survives `.bind()`: React's
+* server-reference `bind` copies `$$typeof`/`$$id` to the bound function but
+* not vinext's own marker symbol.
+*/
+function isUseCacheFunctionReference(fn) {
+	if (typeof fn !== "function") return false;
+	if (Reflect.get(fn, USE_CACHE_FUNCTION_SYMBOL) === true) return true;
+	const reference = fn;
+	return reference.$$typeof === SERVER_REFERENCE_TAG && typeof reference.$$id === "string" && USE_CACHE_SERVER_REFERENCE_ID_RE.test(reference.$$id);
+}
+/**
+* Add Next.js's `$$isPage` marker when `fn` is a `"use cache"` function
+* invoked as a page component or as a page's generateMetadata/generateViewport
+* (create-component-tree.tsx, resolve-metadata.ts `createSegmentProps`). The
+* cache wrapper reads and removes it, so page semantics follow the invocation
+* even when the cached function is defined in (or re-exported from) another
+* module, or bound.
+*/
+function withUseCachePageMarker(fn, props) {
+	return isUseCacheFunctionReference(fn) ? {
+		...props,
+		[APP_PAGE_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
+* reading the marker through a thenable params/searchParams proxy would be
+* observed as a param access.
+*/
+function hasUseCachePageMarker(value) {
+	if (value === null || typeof value !== "object") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return (prototype === Object.prototype || prototype === null) && value["$$isPage"] === true;
+}
 //#endregion
-export { isMarkedAppPagePropsObject, markAppPagePropsForUseCache };
+export { APP_PAGE_USE_CACHE_MARKER, hasUseCachePageMarker, isMarkedAppPagePropsObject, isUseCacheFunctionReference, markAppPagePropsForUseCache, withUseCachePageMarker };

package/dist/shims/internal/app-prefetch-fetch-queue.d.ts

@@ -1,13 +1,13 @@
 //#region src/shims/internal/app-prefetch-fetch-queue.d.ts
-declare function releaseAppPrefetchFetchSlot(response: Response): void;
+export declare function releaseAppPrefetchFetchSlot(response: Response): void;
 /**
  * Low-priority App Router prefetches share a small request queue. The consumer
  * must either snapshot the returned Response with snapshotRscResponse() or call
  * releaseAppPrefetchFetchSlot() when it drops the response without consuming it.
  */
-declare function scheduleAppPrefetchFetch(fetcher: (signal: AbortSignal) => Promise<Response>, priority: "low" | "high"): Promise<Response>;
+export declare function scheduleAppPrefetchFetch(fetcher: (signal: AbortSignal) => Promise<Response>, priority: "low" | "high"): Promise<Response>;
 /** Cancel a queued or in-flight prefetch request. No-op once it has settled. */
-declare function cancelAppPrefetchFetch(promise: Promise<Response> | undefined): void;
+export declare function cancelAppPrefetchFetch(promise: Promise<Response> | undefined): void;
 /**
  * Start a still-queued prefetch request immediately.
  *
@@ -20,6 +20,5 @@ declare function cancelAppPrefetchFetch(promise: Promise<Response> | undefined):
  *
  * No-op when the request has already started or was never queued.
  */
-declare function promoteAppPrefetchFetch(promise: Promise<Response> | undefined): void;
-//#endregion
-export { cancelAppPrefetchFetch, promoteAppPrefetchFetch, releaseAppPrefetchFetchSlot, scheduleAppPrefetchFetch };
+export declare function promoteAppPrefetchFetch(promise: Promise<Response> | undefined): void;
+//#endregion

package/dist/shims/internal/app-prefetch-rsc-request.d.ts

@@ -0,0 +1,13 @@
+//#region src/shims/internal/app-prefetch-rsc-request.d.ts
+export type ResolveAppPrefetchRscRequestOptions = {
+  fullHref: string;
+  headers: Headers;
+  rewrittenPrefetchHref: string | null;
+};
+export type ResolvedAppPrefetchRscRequest = {
+  additionalRscUrls: string[];
+  rscUrl: string;
+};
+/** Resolve the ordinary RSC request identities shared by `<Link>` and `router.prefetch()`. */
+export declare function resolveAppPrefetchRscRequest({ fullHref, headers, rewrittenPrefetchHref }: ResolveAppPrefetchRscRequestOptions): Promise<ResolvedAppPrefetchRscRequest>;
+//#endregion

package/dist/shims/internal/app-prefetch-rsc-request.js

@@ -0,0 +1,12 @@
+import { createRscRequestUrl } from "../../server/app-rsc-cache-busting.js";
+//#region src/shims/internal/app-prefetch-rsc-request.ts
+/** Resolve the ordinary RSC request identities shared by `<Link>` and `router.prefetch()`. */
+async function resolveAppPrefetchRscRequest({ fullHref, headers, rewrittenPrefetchHref }) {
+	const [rscUrl, ...additionalRscUrls] = await Promise.all([createRscRequestUrl(fullHref, headers), ...rewrittenPrefetchHref !== null && rewrittenPrefetchHref !== fullHref ? [createRscRequestUrl(rewrittenPrefetchHref, headers)] : []]);
+	return {
+		additionalRscUrls,
+		rscUrl
+	};
+}
+//#endregion
+export { resolveAppPrefetchRscRequest };

package/dist/shims/internal/app-route-detection.d.ts

@@ -18,6 +18,6 @@ declare global {
  * first (e.g. `link.tsx` normalises to match `trailingSlash` config before
  * calling, while `router.prefetch()` passes the raw user-supplied URL).
  */
-declare function markAppRouteDetectedOnPrefetch(href: string, basePath: string): Promise<void>;
+export declare function markAppRouteDetectedOnPrefetch(href: string, basePath: string): Promise<void>;
 //#endregion
-export { getPagesRouterComponentsMap, markAppRouteDetectedOnPrefetch };
+export { getPagesRouterComponentsMap };

package/dist/shims/internal/app-route-prefetch-policy.d.ts

@@ -10,7 +10,7 @@ declare global {
  * it at all, whether the response is reusable by a later navigation, and which
  * cache TTL family applies.
  */
-type AppRoutePrefetchPolicy = {
+export type AppRoutePrefetchPolicy = {
   cacheForNavigation: boolean;
   /**
    * How the dynamic stale-time signal affects this prefetch. Navigation data
@@ -25,8 +25,7 @@ type AppRoutePrefetchPolicy = {
   requiresRouteTreePrefetch?: true;
   shouldPrefetch: boolean;
 };
-declare function canAutoPrefetchFullAppRoute(href: string): boolean;
-declare function resolveAutoAppRoutePrefetch(href: string): AppRoutePrefetchPolicy;
-declare function resolveFullAppRoutePrefetch(): AppRoutePrefetchPolicy;
-//#endregion
-export { AppRoutePrefetchPolicy, canAutoPrefetchFullAppRoute, resolveAutoAppRoutePrefetch, resolveFullAppRoutePrefetch };
+export declare function canAutoPrefetchFullAppRoute(href: string): boolean;
+export declare function resolveAutoAppRoutePrefetch(href: string): AppRoutePrefetchPolicy;
+export declare function resolveFullAppRoutePrefetch(): AppRoutePrefetchPolicy;
+//#endregion

package/dist/shims/internal/app-route-prefetch-policy.js

@@ -35,6 +35,7 @@ function resolveAutoAppRoutePrefetch(href) {
 	if (routeHref === null) return NO_APP_ROUTE_PREFETCH;
 	const match = matchRouteWithTrie(routeHref, routes, linkPrefetchRouteTrieCache);
 	if (!match) return NO_APP_ROUTE_PREFETCH;
+	if (process.env.NODE_ENV === "production" && process.env.__NEXT_CONFIG_OUTPUT === "export") return resolveFullAppRoutePrefetch();
 	const route = match.route;
 	const requiresRouteTreePrefetch = String(process.env.__NEXT_CACHE_COMPONENTS) === "true" && route.hasRootParams === true;
 	const routeUrl = new URL(routeHref, "http://vinext.local");

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

@@ -1,13 +1,13 @@
 import * as React$1 from "react";
 //#region src/shims/internal/app-router-context.d.ts
-type NavigateOptions = {
+export type NavigateOptions = {
   scroll?: boolean;
 };
-type PrefetchOptions = {
+export type PrefetchOptions = {
   kind?: unknown;
   onInvalidate?: () => void;
 };
-type AppRouterInstance = {
+export type AppRouterInstance = {
   bfcacheId: string;
   back(): void;
   forward(): void;
@@ -21,10 +21,9 @@ type AppRouterInstance = {
    */
   experimental_gesturePush?(href: string, options?: NavigateOptions): void;
 };
-declare const AppRouterContext: React$1.Context<AppRouterInstance | null> | null;
-declare const GlobalLayoutRouterContext: React$1.Context<unknown> | null;
-declare const LayoutRouterContext: React$1.Context<unknown> | null;
-declare const MissingSlotContext: React$1.Context<Set<string>> | null;
-declare const TemplateContext: React$1.Context<unknown> | null;
-//#endregion
-export { AppRouterContext, AppRouterInstance, GlobalLayoutRouterContext, LayoutRouterContext, MissingSlotContext, NavigateOptions, PrefetchOptions, TemplateContext };
+export declare const AppRouterContext: React$1.Context<AppRouterInstance | null> | null;
+export declare const GlobalLayoutRouterContext: React$1.Context<unknown> | null;
+export declare const LayoutRouterContext: React$1.Context<unknown> | null;
+export declare const MissingSlotContext: React$1.Context<Set<string>> | null;
+export declare const TemplateContext: React$1.Context<unknown> | null;
+//#endregion