vinext 1.0.0-beta.9 → 1.0.1

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

@@ -1,25 +1,13 @@
 //#region src/shims/internal/app-prefetch-rsc-request.d.ts
-type ResolveAppPrefetchRscRequestOptions = {
-  canUseCanonicalLoadingShell: boolean;
+export type ResolveAppPrefetchRscRequestOptions = {
   fullHref: string;
   headers: Headers;
-  interceptionContext: string | null;
-  mountedSlotsHeader: string | null;
-  prefetchInlining: boolean;
-  requiresRouteTreePrefetch: boolean;
   rewrittenPrefetchHref: string | null;
 };
-type ResolvedAppPrefetchRscRequest = {
+export type ResolvedAppPrefetchRscRequest = {
   additionalRscUrls: string[];
   rscUrl: string;
-  usesCanonicalPrewarmedRequest: boolean;
 };
-/**
- * Resolve the RSC request identity shared by `<Link>` and `router.prefetch()`.
- * Only full routes and ordinary loading shells without request-specific
- * context can reuse deploy-prewarmed CDN entries. Contextual requests retain
- * their varying headers and deterministic `_rsc` digest.
- */
-declare function resolveAppPrefetchRscRequest({ canUseCanonicalLoadingShell, fullHref, headers, interceptionContext, mountedSlotsHeader, prefetchInlining, requiresRouteTreePrefetch, rewrittenPrefetchHref }: ResolveAppPrefetchRscRequestOptions): Promise<ResolvedAppPrefetchRscRequest>;
-//#endregion
-export { ResolveAppPrefetchRscRequestOptions, ResolvedAppPrefetchRscRequest, resolveAppPrefetchRscRequest };
+/** 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

@@ -1,20 +1,11 @@
-import { canonicalizeLoadingShellRscRequestHeaders, canonicalizePrewarmableRscRequestHeaders, createCanonicalRscRequestUrl, createRscRequestUrl } from "../../server/app-rsc-cache-busting.js";
+import { createRscRequestUrl } from "../../server/app-rsc-cache-busting.js";
 //#region src/shims/internal/app-prefetch-rsc-request.ts
-/**
-* Resolve the RSC request identity shared by `<Link>` and `router.prefetch()`.
-* Only full routes and ordinary loading shells without request-specific
-* context can reuse deploy-prewarmed CDN entries. Contextual requests retain
-* their varying headers and deterministic `_rsc` digest.
-*/
-async function resolveAppPrefetchRscRequest({ canUseCanonicalLoadingShell, fullHref, headers, interceptionContext, mountedSlotsHeader, prefetchInlining, requiresRouteTreePrefetch, rewrittenPrefetchHref }) {
-	const canUseCanonicalSharedRequest = process.env.__NEXT_CONFIG_OUTPUT !== "export" && process.env.__VINEXT_CANONICAL_RSC_REQUESTS === "1" && interceptionContext === null && mountedSlotsHeader === null && (rewrittenPrefetchHref === null || rewrittenPrefetchHref === fullHref) && !requiresRouteTreePrefetch && !prefetchInlining;
-	const usesCanonicalLoadingShell = canUseCanonicalSharedRequest && canUseCanonicalLoadingShell && canonicalizeLoadingShellRscRequestHeaders(headers);
-	const usesCanonicalFullRoute = canUseCanonicalSharedRequest && !usesCanonicalLoadingShell && canonicalizePrewarmableRscRequestHeaders(headers);
-	const [rscUrl, ...additionalRscUrls] = await Promise.all([usesCanonicalFullRoute ? createCanonicalRscRequestUrl(fullHref) : createRscRequestUrl(fullHref, headers), ...rewrittenPrefetchHref !== null && rewrittenPrefetchHref !== fullHref ? [createRscRequestUrl(rewrittenPrefetchHref, headers)] : []]);
+/** 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,
-		usesCanonicalPrewarmedRequest: usesCanonicalLoadingShell || usesCanonicalFullRoute
+		rscUrl
 	};
 }
 //#endregion

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,10 +10,8 @@ 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;
-  /** The selected loading shell has the canonical deploy-warmed identity. */
-  canUseCanonicalLoadingShell?: true;
   /**
    * How the dynamic stale-time signal affects this prefetch. Navigation data
    * takes it verbatim, explicit full prefetches fall back to the static window
@@ -27,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

@@ -45,7 +45,6 @@ function resolveAutoAppRoutePrefetch(href) {
 	const cacheForNavigation = !hasSearchParams && !hasCacheComponentsLearningOnlyDynamicPath && (requiresRouteTreePrefetch || !route.canPrefetchLoadingShell && route.requiresDynamicNavigationRequest !== true);
 	return {
 		cacheForNavigation,
-		...route.canUseCanonicalLoadingShell === true ? { canUseCanonicalLoadingShell: true } : {},
 		dynamicStaleTime: cacheForNavigation ? "verbatim" : "ignore",
 		fallbackTtl: "static",
 		prefetchShellFirst: requiresRouteTreePrefetch || hasSearchParams || !route.isDynamic,

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

package/dist/shims/internal/cache-context-accessor.d.ts

@@ -0,0 +1,16 @@
+import { CacheLifeConfig } from "../cache-request-state.js";
+//#region src/shims/internal/cache-context-accessor.d.ts
+type CacheContextLike = {
+  tags: string[];
+  lifeConfigs: CacheLifeConfig[];
+  variant: string;
+  readRootParamNames?: Set<string>;
+  hasExplicitRevalidate: boolean;
+  hasExplicitExpire: boolean;
+  dynamicNestedCacheError: Error | undefined;
+};
+export declare function _registerCacheContextAccessor(fn: () => CacheContextLike | null): void;
+export declare function getRegisteredCacheContext(): CacheContextLike | null;
+/** Record a root-param dependency on the active public `"use cache"` scope. */
+export declare function _recordUseCacheRootParamRead(name: string): void;
+//#endregion

package/dist/shims/internal/cache-context-accessor.js

@@ -0,0 +1,15 @@
+//#region src/shims/internal/cache-context-accessor.ts
+let getCacheContext = null;
+function _registerCacheContextAccessor(fn) {
+	getCacheContext = fn;
+}
+function getRegisteredCacheContext() {
+	return getCacheContext?.() ?? null;
+}
+/** Record a root-param dependency on the active public `"use cache"` scope. */
+function _recordUseCacheRootParamRead(name) {
+	const context = getRegisteredCacheContext();
+	if (context && context.variant !== "private") context.readRootParamNames?.add(name);
+}
+//#endregion
+export { _recordUseCacheRootParamRead, _registerCacheContextAccessor, getRegisteredCacheContext };

package/dist/shims/internal/cookie-serialize.d.ts

@@ -24,12 +24,12 @@ type SerializeSetCookieOptions = {
   partitioned?: boolean;
   priority?: "low" | "medium" | "high";
 };
-declare function validateCookieName(name: string): void;
+export declare function validateCookieName(name: string): void;
 /**
  * Validate cookie attribute values (path, domain) to prevent injection
  * via semicolons, newlines, or other control characters.
  */
-declare function validateCookieAttributeValue(value: string, attributeName: string): void;
+export declare function validateCookieAttributeValue(value: string, attributeName: string): void;
 /**
  * Build a Set-Cookie header string from a cookie name, value, and attributes.
  *
@@ -43,6 +43,5 @@ declare function validateCookieAttributeValue(value: string, attributeName: stri
  * The caller is responsible for validating the cookie name (typically before
  * mutating any internal state) via `validateCookieName`.
  */
-declare function serializeSetCookie(name: string, value: string | null | undefined, options?: SerializeSetCookieOptions): string;
-//#endregion
-export { serializeSetCookie, validateCookieAttributeValue, validateCookieName };
+export declare function serializeSetCookie(name: string, value: string | null | undefined, options?: SerializeSetCookieOptions): string;
+//#endregion

package/dist/shims/internal/format-url-object.d.ts

@@ -0,0 +1,7 @@
+import { UrlObject } from "node:url";
+//#region src/shims/internal/format-url-object.d.ts
+/** Format Node's public UrlObject shape with the semantics used by Next.js. */
+export declare function formatUrlObject(url: UrlObject): string;
+/** Format a Pages Router UrlObject and surface Next.js's development diagnostics. */
+export declare function formatUrlObjectWithValidation(url: UrlObject): string;
+//#endregion

package/dist/shims/internal/format-url-object.js

@@ -0,0 +1,53 @@
+import { urlQueryToSearchParams } from "../../utils/query.js";
+//#region src/shims/internal/format-url-object.ts
+const slashedProtocols = /https?|ftp|gopher|file/;
+const urlObjectKeys = /* @__PURE__ */ new Set([
+	"auth",
+	"hash",
+	"host",
+	"hostname",
+	"href",
+	"path",
+	"pathname",
+	"port",
+	"protocol",
+	"query",
+	"search",
+	"slashes"
+]);
+/** Format Node's public UrlObject shape with the semantics used by Next.js. */
+function formatUrlObject(url) {
+	let { auth, hostname } = url;
+	let protocol = url.protocol || "";
+	let pathname = url.pathname || "";
+	let hash = url.hash || "";
+	let query = url.query || "";
+	let host = false;
+	auth = auth ? `${encodeURIComponent(auth).replace(/%3A/i, ":")}@` : "";
+	if (url.host) host = auth + url.host;
+	else if (hostname) {
+		host = auth + (hostname.includes(":") ? `[${hostname}]` : hostname);
+		if (url.port) host += `:${url.port}`;
+	}
+	if (query && typeof query === "object") query = String(urlQueryToSearchParams(query));
+	let search = url.search || query && `?${query}` || "";
+	if (protocol && !protocol.endsWith(":")) protocol += ":";
+	if (url.slashes || (!protocol || slashedProtocols.test(protocol)) && host !== false) {
+		host = `//${host || ""}`;
+		if (pathname && !pathname.startsWith("/")) pathname = `/${pathname}`;
+	} else if (!host) host = "";
+	if (hash && !hash.startsWith("#")) hash = `#${hash}`;
+	if (search && !search.startsWith("?")) search = `?${search}`;
+	pathname = pathname.replace(/[?#]/g, encodeURIComponent);
+	search = search.replace("#", "%23");
+	return `${protocol}${host}${pathname}${search}${hash}`;
+}
+/** Format a Pages Router UrlObject and surface Next.js's development diagnostics. */
+function formatUrlObjectWithValidation(url) {
+	if (process.env.NODE_ENV === "development") {
+		for (const key of Object.keys(url)) if (!urlObjectKeys.has(key)) console.warn(`Unknown key passed via urlObject into url.format: ${key}`);
+	}
+	return formatUrlObject(url);
+}
+//#endregion
+export { formatUrlObject, formatUrlObjectWithValidation };

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

@@ -0,0 +1,74 @@
+import { RenderRequestApiKind } from "../../server/cache-proof.js";
+import { HeadersContext } from "../headers.js";
+//#region src/shims/internal/headers-state.d.ts
+export type HeadersAccessPhase = "render" | "action" | "route-handler";
+/**
+ * Whether the current render has used a dynamic API. Unlike
+ * `dynamicUsageDetected`, nothing clears it, and one object is shared by every
+ * child scope of the request, so usage inside isolated scopes (such as the
+ * layout probe) stays visible to later readers.
+ */
+export type RenderDynamicLatch = {
+  dynamic: boolean;
+  listeners: Set<() => void>;
+};
+export declare function createRenderDynamicLatch(): RenderDynamicLatch;
+export type VinextHeadersShimState = {
+  headersContext: HeadersContext | null;
+  dynamicUsageDetected: boolean;
+  renderDynamicLatch: RenderDynamicLatch;
+  renderRequestApiUsage: Set<RenderRequestApiKind>;
+  connectionProbe: ConnectionProbeState | null;
+  /** Error recorded by throwIfInsideCacheScope for dev diagnostics, persists even if caught by user code. */
+  invalidDynamicUsageError: unknown;
+  pendingSetCookies: string[];
+  draftModeCookieHeader: string | null;
+  phase: HeadersAccessPhase;
+};
+export type ConnectionProbeState = {
+  active: boolean;
+  dynamicUsageTarget: VinextHeadersShimState;
+  interrupted: boolean;
+  interrupt: () => void;
+  pending: Promise<never>;
+};
+export type ConnectionProbeResult<T> = {
+  completed: true;
+  result: T;
+} | {
+  completed: false;
+};
+export declare const headersShimAls: import("node:async_hooks").AsyncLocalStorage<VinextHeadersShimState>;
+export declare function getHeadersShimState(): VinextHeadersShimState;
+/**
+ * Dynamic usage flag — set when a component calls connection(), cookies(),
+ * headers(), or noStore() during rendering. When true, ISR caching is
+ * bypassed and the response gets Cache-Control: no-store.
+ */
+/**
+ * Mark the current render as requiring dynamic (uncached) rendering.
+ * Called by connection(), cookies(), headers(), and noStore().
+ */
+export declare function markDynamicUsage(): void;
+/** Whether the current render has used a dynamic API at any point so far. */
+export declare function isRenderDynamicLatched(): boolean;
+/**
+ * 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.
+ */
+export declare function onRenderDynamicLatched(listener: () => void): () => void;
+export declare function markRenderRequestApiUsage(kind: RenderRequestApiKind): void;
+export declare function throwIfStaticGenerationAccessError(): void;
+/** Whether work is executing inside a cache boundary that owns its reuse. */
+export declare function isInsideAnyCacheScope(): boolean;
+/**
+ * Throw if the current execution is inside a "use cache" or unstable_cache()
+ * scope. Called by dynamic request APIs (headers, cookies, connection) to
+ * prevent request-specific data from being frozen into cached results.
+ *
+ * @param apiName - The name of the API being called (e.g. "connection()")
+ */
+export declare function throwIfInsideCacheScope(apiName: string): void;
+export declare function getHeadersAccessPhase(): HeadersAccessPhase;
+//#endregion

package/dist/shims/internal/headers-state.js

@@ -0,0 +1,157 @@
+import { getOrCreateAls } from "./als-registry.js";
+import { ensureRenderDynamicLatch, getRequestContext, isInsideUnifiedScope } from "../unified-request-context.js";
+//#region src/shims/internal/headers-state.ts
+function createRenderDynamicLatch() {
+	return {
+		dynamic: false,
+		listeners: /* @__PURE__ */ new Set()
+	};
+}
+const _FALLBACK_KEY = Symbol.for("vinext.nextHeadersShim.fallback");
+const _g = globalThis;
+const headersShimAls = getOrCreateAls("vinext.nextHeadersShim.als");
+const _fallbackState = _g[_FALLBACK_KEY] ??= {
+	headersContext: null,
+	dynamicUsageDetected: false,
+	renderDynamicLatch: createRenderDynamicLatch(),
+	renderRequestApiUsage: /* @__PURE__ */ new Set(),
+	connectionProbe: null,
+	invalidDynamicUsageError: null,
+	pendingSetCookies: [],
+	draftModeCookieHeader: null,
+	phase: "render"
+};
+function getHeadersShimState() {
+	if (isInsideUnifiedScope()) return getRequestContext();
+	return headersShimAls.getStore() ?? _fallbackState;
+}
+/**
+* Dynamic usage flag — set when a component calls connection(), cookies(),
+* headers(), or noStore() during rendering. When true, ISR caching is
+* bypassed and the response gets Cache-Control: no-store.
+*/
+/**
+* Mark the current render as requiring dynamic (uncached) rendering.
+* Called by connection(), cookies(), headers(), and noStore().
+*/
+function markDynamicUsage() {
+	const state = getHeadersShimState();
+	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(getHeadersShimState()).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(getHeadersShimState());
+	if (latch.dynamic) return () => {};
+	latch.listeners.add(listener);
+	return () => {
+		latch.listeners.delete(listener);
+	};
+}
+function forEachConnectionProbeTarget(state, visit) {
+	let target = state.connectionProbe?.dynamicUsageTarget ?? null;
+	const seen = /* @__PURE__ */ new Set([state]);
+	while (target && !seen.has(target)) {
+		seen.add(target);
+		visit(target);
+		target = target.connectionProbe?.dynamicUsageTarget ?? null;
+	}
+}
+function propagateInvalidDynamicUsageError(state, error) {
+	forEachConnectionProbeTarget(state, (target) => {
+		if (target.invalidDynamicUsageError == null) target.invalidDynamicUsageError = error;
+	});
+}
+function markRenderRequestApiUsage(kind) {
+	getHeadersShimState().renderRequestApiUsage.add(kind);
+}
+function throwIfStaticGenerationAccessError() {
+	const accessError = getHeadersShimState().headersContext?.accessError;
+	if (accessError) throw accessError;
+}
+/** Symbol used by cache-runtime.ts to store the "use cache" ALS on globalThis */
+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 _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.call(value);
+}
+function _getUseCacheGuardContext() {
+	const store = _getGlobalCacheScopeStore(_USE_CACHE_ALS_KEY);
+	if (!store || typeof store !== "object") return null;
+	return store;
+}
+function _isInsidePublicUseCache() {
+	const ctx = _getUseCacheGuardContext();
+	return ctx !== null && ctx.variant !== "private";
+}
+function _isInsideUnstableCache() {
+	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()
+* scope. Called by dynamic request APIs (headers, cookies, connection) to
+* prevent request-specific data from being frozen into cached results.
+*
+* @param apiName - The name of the API being called (e.g. "connection()")
+*/
+function throwIfInsideCacheScope(apiName) {
+	if (_isInsidePublicUseCache()) {
+		const error = /* @__PURE__ */ new Error(`\`${apiName}\` cannot be called inside "use cache". If you need this data inside a cached function, call \`${apiName}\` outside and pass the required data as an argument.`);
+		try {
+			const cacheCtx = _getUseCacheGuardContext();
+			if (cacheCtx) cacheCtx.invalidDynamicUsageError = error;
+			const ctx = getRequestContext();
+			if (ctx) ctx.invalidDynamicUsageError = error;
+			propagateInvalidDynamicUsageError(getHeadersShimState(), error);
+		} catch {}
+		throw error;
+	}
+	if (_isInsideUnstableCache()) {
+		const error = /* @__PURE__ */ new Error(`\`${apiName}\` cannot be called inside a function cached with \`unstable_cache()\`. If you need this data inside a cached function, call \`${apiName}\` outside and pass the required data as an argument.`);
+		try {
+			const ctx = getRequestContext();
+			if (ctx) ctx.invalidDynamicUsageError = error;
+			propagateInvalidDynamicUsageError(getHeadersShimState(), error);
+		} catch {}
+		throw error;
+	}
+}
+function getHeadersAccessPhase() {
+	return getHeadersShimState().phase;
+}
+//#endregion
+export { createRenderDynamicLatch, getHeadersAccessPhase, getHeadersShimState, headersShimAls, isInsideAnyCacheScope, isRenderDynamicLatched, markDynamicUsage, markRenderRequestApiUsage, onRenderDynamicLatched, throwIfInsideCacheScope, throwIfStaticGenerationAccessError };

package/dist/shims/internal/hybrid-client-route-owner-direct.d.ts

@@ -1,6 +1,6 @@
 import { VinextLinkPrefetchRoute, VinextPagesLinkPrefetchRoute } from "../../client/vinext-next-data.js";
 //#region src/shims/internal/hybrid-client-route-owner-direct.d.ts
-type HybridClientOwner = "app" | "document" | "pages";
+export type HybridClientOwner = "app" | "document" | "pages";
 type HybridClientRouteMatches = {
   appMatch: VinextLinkPrefetchRoute | null;
   pagesMatch: VinextPagesLinkPrefetchRoute | null;
@@ -11,9 +11,8 @@ declare global {
     __VINEXT_PAGES_LINK_PREFETCH_ROUTES__?: VinextPagesLinkPrefetchRoute[];
   }
 }
-declare function resolveSameOriginAppPathname(href: string, basePath: string): string | null;
-declare function matchDirectHybridClientRoutes(href: string, basePath: string): HybridClientRouteMatches;
-declare function resolveMatchedHybridClientRouteOwner({ appMatch, pagesMatch }: HybridClientRouteMatches): HybridClientOwner | null;
-declare function resolveDirectHybridClientRouteOwner(href: string, basePath: string): HybridClientOwner | null;
-//#endregion
-export { HybridClientOwner, matchDirectHybridClientRoutes, resolveDirectHybridClientRouteOwner, resolveMatchedHybridClientRouteOwner, resolveSameOriginAppPathname };
+export declare function resolveSameOriginAppPathname(href: string, basePath: string): string | null;
+export declare function matchDirectHybridClientRoutes(href: string, basePath: string): HybridClientRouteMatches;
+export declare function resolveMatchedHybridClientRouteOwner({ appMatch, pagesMatch }: HybridClientRouteMatches): HybridClientOwner | null;
+export declare function resolveDirectHybridClientRouteOwner(href: string, basePath: string): HybridClientOwner | null;
+//#endregion

package/dist/shims/internal/hybrid-client-route-owner.d.ts

@@ -1,6 +1,6 @@
 import { HybridClientOwner } from "./hybrid-client-route-owner-direct.js";
 //#region src/shims/internal/hybrid-client-route-owner.d.ts
-declare function resolveHybridClientRewriteHref(href: string, basePath: string): string | null;
+export declare function resolveHybridClientRewriteHref(href: string, basePath: string): string | null;
 /**
  * Decide which router should own a soft-navigated URL. Returns:
  *   - "app"    → the App Router runtime handles the navigation (RSC fetch).
@@ -13,6 +13,6 @@ declare function resolveHybridClientRewriteHref(href: string, basePath: string):
  * matcher trie produces the same result the server will see when the
  * request lands.
  */
-declare function resolveHybridClientRouteOwner(href: string, basePath: string): HybridClientOwner | null;
+export declare function resolveHybridClientRouteOwner(href: string, basePath: string): HybridClientOwner | null;
 //#endregion
-export { type HybridClientOwner, resolveHybridClientRewriteHref, resolveHybridClientRouteOwner };
+export type { HybridClientOwner };

package/dist/shims/internal/hybrid-client-route-owner.js

@@ -32,12 +32,13 @@ function resolveClientRewrite(href, basePath, rewrites, continueAfterMatch = fal
 		if (pathname === null) return null;
 		const url = new URL(currentHref, window.location.href);
 		const headers = new Headers({ "user-agent": globalThis.navigator?.userAgent ?? "" });
-		const result = matchClientRewrite(pathname, rewrite, {
+		const context = {
 			cookies: parseCookies(globalThis.document?.cookie ?? ""),
 			headers,
 			host: url.hostname,
 			query: url.searchParams
-		}, basePathState);
+		};
+		const result = matchClientRewrite(pathname, rewrite, context, basePathState);
 		if (result === null) continue;
 		if (result.kind === "server") return { kind: "document" };
 		currentHref = mergeRewriteQuery(currentHref, result.destination);