vinext 1.0.0 → 1.1.0

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

@@ -1,3 +1,4 @@
+import { VinextAssetFetcher } from "../server/multi-stage.js";
 import { CacheHandlerValue, IncrementalCacheValue } from "./cache-handler.js";
 import { setCdnCacheAdapter } from "./cdn-cache-state.js";
 //#region src/shims/cdn-cache.d.ts
@@ -10,6 +11,8 @@ export type CdnCacheableHeaderInput = {
    * when no cacheable policy applies.
    */
   cacheControl: string;
+  /** Explicit endpoint policy returned to clients, independent of shared admission. */
+  browserCacheControl?: string;
   /**
    * True when this is a freshly-rendered **streaming** response whose
    * dynamic-ness is not yet proven (late Server Component request-API usage can
@@ -47,8 +50,10 @@ export type CdnResponsePolicy = {
   /** Whether provider policy explicitly opts out of storage. */
   hasExplicitNonCacheablePolicy(headers: Headers, baseline?: Headers): boolean;
 };
+/** Split Cache-Control directives without treating quoted commas as separators. */
+export declare function splitCacheControlDirectives(cacheControl: string): string[];
 /** Whether a Cache-Control value contains an exact non-cacheable directive. */
-export declare function isNonCacheableCacheControl(cacheControl: string): boolean;
+export declare function isNonCacheableCacheControl(cacheControl: string, scope?: "shared" | "browser"): 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.
@@ -100,6 +105,10 @@ export type CdnCacheAdapter = {
    * edge owns serving.
    */
   get(key: string, ctx?: Record<string, unknown>): Promise<CacheHandlerValue | null>;
+  /** Also supplies build-time PAGES entries for pages without getStaticProps. */
+  readonly hasPrerenderedPages?: boolean;
+  /** Optional host asset fetcher resolved by the adapter's platform bindings. */
+  readonly assets?: VinextAssetFetcher;
   /**
    * Persist a freshly-rendered page-level artifact.
    *

package/dist/shims/cdn-cache.js

@@ -1,17 +1,16 @@
 import { getExplicitCdnCacheAdapter, setCdnCacheAdapter } from "./cdn-cache-state.js";
 //#region src/shims/cdn-cache.ts
-/** Whether a Cache-Control value contains an exact non-cacheable directive. */
-function isNonCacheableCacheControl(cacheControl) {
+/** Split Cache-Control directives without treating quoted commas as separators. */
+function splitCacheControlDirectives(cacheControl) {
+	const directives = [];
 	let start = 0;
 	let quoted = false;
 	let escaped = false;
 	for (let index = 0; index <= cacheControl.length; index++) {
 		const char = cacheControl[index];
 		if (index === cacheControl.length || char === "," && !quoted) {
-			const directive = cacheControl.slice(start, index);
-			const equals = directive.indexOf("=");
-			const name = (equals === -1 ? directive : directive.slice(0, equals)).trim().toLowerCase();
-			if (name === "no-store" || equals === -1 && (name === "private" || name === "no-cache")) return true;
+			const directive = cacheControl.slice(start, index).trim();
+			if (directive) directives.push(directive);
 			start = index + 1;
 			continue;
 		}
@@ -22,7 +21,15 @@ function isNonCacheableCacheControl(cacheControl) {
 		if (char === "\"" && !escaped) quoted = !quoted;
 		escaped = false;
 	}
-	return false;
+	return directives;
+}
+/** Whether a Cache-Control value contains an exact non-cacheable directive. */
+function isNonCacheableCacheControl(cacheControl, scope = "shared") {
+	return splitCacheControlDirectives(cacheControl).some((directive) => {
+		const equals = directive.indexOf("=");
+		const name = (equals === -1 ? directive : directive.slice(0, equals)).trim().toLowerCase();
+		return name === "no-store" || equals === -1 && (name === "no-cache" || scope === "shared" && name === "private");
+	});
 }
 const PENDING_DYNAMIC_CACHE_CONTROL = "no-store, must-revalidate";
 /**
@@ -48,7 +55,7 @@ var DefaultCdnCacheAdapter = class {
 	}
 	buildResponseHeaders(input) {
 		if (input.pendingDynamicCheck) return { "Cache-Control": PENDING_DYNAMIC_CACHE_CONTROL };
-		return { "Cache-Control": input.cacheControl };
+		return { "Cache-Control": input.browserCacheControl ?? input.cacheControl };
 	}
 	buildResponseIdentityHeaders() {
 		return this.buildIdentity ? { "X-Vinext-Build-Id": this.buildIdentity } : {};
@@ -88,4 +95,4 @@ function getCdnCacheAdapter() {
 	return _defaultAdapter ??= new DefaultCdnCacheAdapter();
 }
 //#endregion
-export { DefaultCdnCacheAdapter, getCdnCacheAdapter, isNonCacheableCacheControl, setCdnCacheAdapter };
+export { DefaultCdnCacheAdapter, getCdnCacheAdapter, isNonCacheableCacheControl, setCdnCacheAdapter, splitCacheControlDirectives };

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

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

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

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

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

@@ -29,6 +29,11 @@ type CapturedError = {
 type RedirectBoundaryState = {
   redirect: string | null;
   redirectType: "push" | "replace" | null;
+  previousResetKey: string | null;
+};
+type RedirectBoundaryProps = {
+  children?: React.ReactNode;
+  resetKey?: string | null;
 };
 type ErrorBoundaryInnerProps = {
   isImplicitRootErrorBoundary?: boolean;
@@ -39,18 +44,13 @@ export type ErrorBoundaryState = {
   previousPathname: string | null;
   previousResetKey: string | null;
 };
-export declare class RedirectErrorBoundary extends React.Component<{
-  children?: React.ReactNode;
-}, RedirectBoundaryState> {
-  constructor(props: {
-    children?: React.ReactNode;
-  });
-  static getDerivedStateFromError(error: unknown): RedirectBoundaryState;
+export declare class RedirectErrorBoundary extends React.Component<RedirectBoundaryProps, RedirectBoundaryState> {
+  constructor(props: RedirectBoundaryProps);
+  static getDerivedStateFromProps(props: RedirectBoundaryProps, state: RedirectBoundaryState): RedirectBoundaryState | null;
+  static getDerivedStateFromError(error: unknown): Omit<RedirectBoundaryState, "previousResetKey">;
   render(): string | number | bigint | boolean | React.JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | Iterable<React.ReactNode> | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | React.ReactPortal | null | undefined> | null | undefined;
 }
-export declare function RedirectBoundary({ children }: {
-  children?: React.ReactNode;
-}): React.JSX.Element;
+export declare function RedirectBoundary({ children, resetKey }: RedirectBoundaryProps): React.JSX.Element;
 /**
  * Generic ErrorBoundary used to wrap route segments with error.tsx.
  * This must be a client component since error boundaries use

package/dist/shims/error-boundary.js

@@ -2,7 +2,7 @@
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
 import { decodeRedirectError, isRedirectError } from "./navigation-errors.js";
 import "./navigation-server.js";
-import { useErrorBoundaryPathname, useErrorBoundaryRouter } from "./error-boundary-navigation.js";
+import { isRedirectToCurrentUrl, useErrorBoundaryPathname, useErrorBoundaryRouter } from "./error-boundary-navigation.js";
 import DefaultGlobalError from "./default-global-error.js";
 import { handleAppNavigationFailure } from "../client/app-nav-failure-handler.js";
 import { VINEXT_DEV_ERROR_RECOVERY_EVENT } from "../utils/dev-error-recovery-event.js";
@@ -43,9 +43,13 @@ function removeDevErrorRecoveryListener(listener) {
 	if (typeof window === "undefined") return;
 	window.removeEventListener(VINEXT_DEV_ERROR_RECOVERY_EVENT, listener);
 }
-function HandleRedirect({ redirect, redirectType, reset }) {
+function HandleRedirect({ redirect, redirectType, reset, stopsSelfRedirect }) {
 	const router = useErrorBoundaryRouter();
 	React.useEffect(() => {
+		if (stopsSelfRedirect && isRedirectToCurrentUrl(redirect)) {
+			console.error("[vinext] redirect() resolved to the current URL — not following it, to prevent an infinite loop.");
+			return;
+		}
 		React.startTransition(() => {
 			if (redirectType === "push") router.push(redirect);
 			else router.replace(redirect);
@@ -55,7 +59,8 @@ function HandleRedirect({ redirect, redirectType, reset }) {
 		redirect,
 		redirectType,
 		reset,
-		router
+		router,
+		stopsSelfRedirect
 	]);
 	return null;
 }
@@ -64,7 +69,17 @@ var RedirectErrorBoundary = class extends React.Component {
 		super(props);
 		this.state = {
 			redirect: null,
-			redirectType: null
+			redirectType: null,
+			previousResetKey: normalizeBoundaryResetKey(props.resetKey)
+		};
+	}
+	static getDerivedStateFromProps(props, state) {
+		const resetKey = normalizeBoundaryResetKey(props.resetKey);
+		if (resetKey === state.previousResetKey) return null;
+		return {
+			redirect: null,
+			redirectType: null,
+			previousResetKey: resetKey
 		};
 	}
 	static getDerivedStateFromError(error) {
@@ -90,13 +105,17 @@ var RedirectErrorBoundary = class extends React.Component {
 			reset: () => this.setState({
 				redirect: null,
 				redirectType: null
-			})
+			}),
+			stopsSelfRedirect: this.props.resetKey !== void 0
 		});
 		return this.props.children;
 	}
 };
-function RedirectBoundary({ children }) {
-	return /* @__PURE__ */ jsx(RedirectErrorBoundary, { children });
+function RedirectBoundary({ children, resetKey }) {
+	return /* @__PURE__ */ jsx(RedirectErrorBoundary, {
+		resetKey,
+		children
+	});
 }
 /**
 * Generic ErrorBoundary used to wrap route segments with error.tsx.

package/dist/shims/error.d.ts

@@ -1,5 +1,6 @@
 import React from "react";
 import { IncomingMessage, ServerResponse } from "node:http";
+import { ErrorInfo, catchError as catchError$1, unstable_catchError as unstable_catchError$1 } from "@vinext/types/next/vinext/error";
 //#region src/shims/error.d.ts
 export type ErrorProps = {
   statusCode: number;
@@ -21,22 +22,7 @@ declare class ErrorComponent<P = {}> extends React.Component<P & ErrorProps> {
   static origGetInitialProps: typeof getErrorInitialProps;
   render(): React.ReactElement;
 }
-export type ErrorInfo = {
-  error: Error;
-  reset: () => void;
-  unstable_retry: () => void;
-};
-type _UserProps = Record<string, unknown>;
-/**
- * Wrap a fallback render function in a Component-level error boundary.
- * Returns a Component that renders `children` and, on error, renders the
- * supplied fallback with an `ErrorInfo` value.
- *
- * Ported from Next.js:
- *   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/catch-error.tsx
- */
-export declare function unstable_catchError<P extends _UserProps>(fallback: (props: P, errorInfo: ErrorInfo) => React.ReactNode): React.ComponentType<P & {
-  children?: React.ReactNode;
-}>;
+export declare const catchError: typeof catchError$1;
+export declare const unstable_catchError: typeof unstable_catchError$1;
 //#endregion
-export { ErrorComponent as default };
+export { type ErrorInfo, ErrorComponent as default };

package/dist/shims/error.js

@@ -13,9 +13,9 @@ import React from "react";
 * Used by apps that import `import Error from 'next/error'` for
 * custom error handling in getServerSideProps or API routes.
 *
-* Also re-exports the unstable App Router error-boundary HOC
-* (`unstable_catchError`) and its `ErrorInfo` type, mirroring
-* `next/error`'s public surface.
+* Also exports the App Router error-boundary HOC (`catchError`, plus its
+* former unstable name) and its `ErrorInfo` type, mirroring `next/error`'s
+* public surface.
 */
 const statusCodes = {
 	400: "Bad Request",
@@ -83,7 +83,7 @@ var ErrorComponent = class extends React.Component {
 const _CatchErrorAppRouterContext = AppRouterContext ?? React.createContext(null);
 var _CatchError = class extends React.Component {
 	static contextType = _CatchErrorAppRouterContext;
-	static displayName = "unstable_catchError(Next.CatchError)";
+	static displayName = "catchError(Next.CatchError)";
 	constructor(props) {
 		super(props);
 		this.state = {
@@ -108,19 +108,24 @@ var _CatchError = class extends React.Component {
 	reset = () => {
 		this.setState({ error: null });
 	};
-	unstable_retry = () => {
-		if (this.props.isPagesRouter) throw new Error("`unstable_retry()` can only be used in the App Router. Use `reset()` in the Pages Router.");
+	retry = () => {
+		if (this.props.isPagesRouter) throw new Error("`retry()` can only be used in the App Router. Use `reset()` in the Pages Router.");
 		React.startTransition(() => {
 			this.context?.refresh();
 			this.reset();
 		});
 	};
+	unstable_retry = () => {
+		if (this.props.isPagesRouter) throw new Error("`unstable_retry()` can only be used in the App Router. Use `reset()` in the Pages Router.");
+		this.retry();
+	};
 	render() {
 		if (this.state.error) {
 			const Fallback = this.props.fallback;
 			const errorInfo = {
-				error: this.state.error.thrownValue instanceof Error ? this.state.error.thrownValue : new Error(String(this.state.error.thrownValue)),
+				error: this.state.error.thrownValue,
 				reset: this.reset,
+				retry: this.retry,
 				unstable_retry: this.unstable_retry
 			};
 			return React.createElement(Fallback, {
@@ -139,7 +144,7 @@ var _CatchError = class extends React.Component {
 * Ported from Next.js:
 *   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/catch-error.tsx
 */
-function unstable_catchError(fallback) {
+function createCatchError(fallback) {
 	const Fallback = ({ props, errorInfo }) => fallback(props, errorInfo);
 	Fallback.displayName = fallback.name || "CatchErrorFallback";
 	function CatchErrorBoundary(allProps) {
@@ -154,8 +159,10 @@ function unstable_catchError(fallback) {
 			props: forwardedProps
 		}, children);
 	}
-	CatchErrorBoundary.displayName = `unstable_catchError(${fallback.name || "CatchErrorFallback"})`;
+	CatchErrorBoundary.displayName = `catchError(${fallback.name || "CatchErrorFallback"})`;
 	return CatchErrorBoundary;
 }
+const catchError = createCatchError;
+const unstable_catchError = createCatchError;
 //#endregion
-export { ErrorComponent as default, unstable_catchError };
+export { catchError, ErrorComponent as default, unstable_catchError };

package/dist/shims/error.react-server.d.ts

@@ -1,8 +1,6 @@
+import { ErrorInfo } from "./error.js";
 //#region src/shims/error.react-server.d.ts
-export type ErrorInfo = {
-  error: unknown;
-  reset: () => void;
-  unstable_retry: () => void;
-};
 export declare function unstable_catchError(): never;
-//#endregion
+export declare function catchError(): never;
+//#endregion
+export type { ErrorInfo };

package/dist/shims/error.react-server.js

@@ -2,5 +2,8 @@
 function unstable_catchError() {
 	throw new Error("`unstable_catchError` can only be used in Client Components.");
 }
+function catchError() {
+	throw new Error("`catchError` can only be used in Client Components.");
+}
 //#endregion
-export { unstable_catchError };
+export { catchError, unstable_catchError };

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

@@ -103,6 +103,12 @@ export declare function setRefreshStaleFetchesInForeground(enabled: boolean): vo
  *   try { await render(); } finally { cleanup(); }
  */
 export declare function withFetchCache(): () => void;
+/**
+ * Run `fn` with the request's fetch settings but its own record of the tags and
+ * URLs its fetches touch, so work done on the request's behalf after the fact
+ * (a background regeneration) leaves the request's response untouched.
+ */
+export declare function runWithDetachedFetchObservations<T>(fn: () => Promise<T>): Promise<T>;
 /**
  * Run an async function with patched fetch caching enabled.
  * Uses `AsyncLocalStorage.run()` for proper per-request isolation

package/dist/shims/fetch-cache.js

@@ -4,7 +4,8 @@ import { getRequestExecutionContext } from "./request-context.js";
 import { getDataCacheHandler } from "./cache-handler.js";
 import { encodeCacheTags } from "../utils/encode-cache-tag.js";
 import { traceAppFetch } from "../server/app-fetch-tracing.js";
-import { getHeadersContext, isInsideAnyCacheScope, markDynamicUsage } from "./headers.js";
+import { isInsideAnyCacheScope, markDynamicUsage } from "./internal/headers-state.js";
+import { getHeadersContext } from "./headers.js";
 import { _hasPendingRevalidatedTag, _setRequestScopedCacheLife } from "./cache-request-state.js";
 import { Buffer } from "node:buffer";
 //#region src/shims/fetch-cache.ts
@@ -688,11 +689,12 @@ function createPatchedFetch() {
 			recordDynamicFetchObservation(input);
 			return recordFetchOutcome(await dedupeFetch(input, cleanInit), "skip", "auto no cache");
 		}
+		const tags = encodeCacheTags(nextOpts?.tags ?? []);
 		let revalidateSeconds;
 		if (cacheDirective === "force-cache") revalidateSeconds = nextOpts?.revalidate && typeof nextOpts.revalidate === "number" ? nextOpts.revalidate : ONE_YEAR_SECONDS;
 		else if (nextOpts?.revalidate === false) revalidateSeconds = ONE_YEAR_SECONDS;
 		else if (typeof nextOpts?.revalidate === "number" && nextOpts.revalidate > 0) revalidateSeconds = nextOpts.revalidate;
-		else if (nextOpts?.tags && nextOpts.tags.length > 0) {
+		else if (tags.length > 0) {
 			const routeRevalidate = _getState().currentFetchRevalidate;
 			if (routeRevalidate === 0) {
 				const cleanInit = stripNextFromInit(init, cacheDirective);
@@ -712,7 +714,6 @@ function createPatchedFetch() {
 			recordFiniteFetchRevalidate(nextOpts.revalidate);
 		}
 		const reqTags = _getState().currentRequestTags;
-		const tags = encodeCacheTags(nextOpts?.tags ?? []);
 		if (tags.length > 0) {
 			for (const tag of tags) if (!reqTags.includes(tag)) reqTags.push(tag);
 		}
@@ -833,6 +834,24 @@ function withFetchCache() {
 	};
 }
 /**
+* Run `fn` with the request's fetch settings but its own record of the tags and
+* URLs its fetches touch, so work done on the request's behalf after the fact
+* (a background regeneration) leaves the request's response untouched.
+*/
+function runWithDetachedFetchObservations(fn) {
+	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((uCtx) => {
+		uCtx.cacheableFetchUrls = /* @__PURE__ */ new Set();
+		uCtx.currentRequestTags = [];
+		uCtx.dynamicFetchUrls = /* @__PURE__ */ new Set();
+	}, fn);
+	return _als.run({
+		..._getState(),
+		cacheableFetchUrls: /* @__PURE__ */ new Set(),
+		currentRequestTags: [],
+		dynamicFetchUrls: /* @__PURE__ */ new Set()
+	}, fn);
+}
+/**
 * Run an async function with patched fetch caching enabled.
 * Uses `AsyncLocalStorage.run()` for proper per-request isolation
 * of collected fetch tags in concurrent server environments.
@@ -896,4 +915,4 @@ function getOriginalFetch() {
 	return originalFetch;
 }
 //#endregion
-export { _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getCurrentFetchSoftTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchRevalidate, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault, setRefreshStaleFetchesInForeground, withFetchCache };
+export { _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getCurrentFetchSoftTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithDetachedFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchRevalidate, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault, setRefreshStaleFetchesInForeground, withFetchCache };

package/dist/shims/form.js

@@ -4,9 +4,9 @@ import { VINEXT_MOUNTED_SLOTS_HEADER } from "../server/app-rsc-vary.js";
 import "../server/headers.js";
 import { assertSafeNavigationUrl } from "./url-safety.js";
 import { APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL } from "../server/app-rsc-render-mode.js";
+import { withBasePath } from "./url-utils.js";
 import { AppElementsWire } from "../server/app-elements-wire.js";
 import "../server/app-elements.js";
-import { withBasePath } from "./url-utils.js";
 import { createRscRequestHeaders, createRscRequestUrl } from "../server/app-rsc-cache-busting.js";
 import { hasAppNavigationRuntime } from "../client/navigation-runtime.js";
 import { getMountedSlotsHeader, getPrefetchInterceptionContext, getPrefetchedUrls, hasPrefetchCacheEntryForNavigation, navigateClientSide, prefetchRscResponse } from "./navigation.js";

package/dist/shims/headers.d.ts

@@ -1,4 +1,6 @@
 import { RenderRequestApiKind } from "../server/cache-proof.js";
+import { CacheLifeConfig } from "./cache-request-state.js";
+import { ConnectionProbeResult, HeadersAccessPhase, RenderDynamicLatch, VinextHeadersShimState, createRenderDynamicLatch, getHeadersAccessPhase, isInsideAnyCacheScope, isRenderDynamicLatched, markDynamicUsage, markRenderRequestApiUsage, onRenderDynamicLatched, throwIfInsideCacheScope, throwIfStaticGenerationAccessError } from "./internal/headers-state.js";
 import { ReadonlyRequestCookies } from "@vinext/types/next/upstream/dist/server/web/spec-extension/adapters/request-cookies";
 import { ResponseCookie } from "@vinext/types/next/upstream/dist/compiled/@edge-runtime/cookies/index";
 //#region src/shims/headers.d.ts
@@ -16,61 +18,6 @@ export type HeadersContext = {
 type HeadersContextFromRequestOptions = {
   draftModeSecret?: string;
 };
-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;
-};
-type ConnectionProbeState = {
-  active: boolean;
-  dynamicUsageTarget: VinextHeadersShimState;
-  interrupted: boolean;
-  interrupt: () => void;
-  pending: Promise<never>;
-};
-type ConnectionProbeResult<T> = {
-  completed: true;
-  result: T;
-} | {
-  completed: false;
-};
-/**
- * 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;
 /**
  * Measure dynamic usage in a child async scope without clearing the parent.
  * Concurrent work that already belongs to the request (such as deferred
@@ -81,22 +28,22 @@ export declare function runWithIsolatedDynamicUsage<T>(fn: () => T | Promise<T>)
   result: T;
   dynamicDetected: boolean;
 }>;
-export declare function markRenderRequestApiUsage(kind: RenderRequestApiKind): void;
-export declare function throwIfStaticGenerationAccessError(): void;
+/**
+ * Run a pre-render probe without letting its dynamic API usage classify the
+ * request. Next.js has no probe: only the render decides whether a page is
+ * dynamic, and the render runs the probed layouts and page again. Returns the
+ * probe's own usage and cacheLife for a caller whose probe response replaces
+ * the render.
+ */
+export declare function runWithDetachedDynamicUsage<T>(fn: () => T | Promise<T>): Promise<{
+  result: T;
+  dynamicDetected: boolean;
+  cacheLife: CacheLifeConfig | null;
+}>;
 export declare function runWithConnectionProbe<T>(fn: () => T | Promise<T>): Promise<ConnectionProbeResult<T>>;
 export declare function suspendConnectionProbe(): Promise<never> | null;
 export declare function peekRenderRequestApiUsage(): RenderRequestApiKind[];
 export declare function consumeRenderRequestApiUsage(): RenderRequestApiKind[];
-/** 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;
 /**
  * Check, consume, and return any invalid dynamic usage error recorded during
  * the render (e.g. cookies() called inside "use cache"). This error persists
@@ -121,7 +68,6 @@ export declare function consumeDynamicUsage(): boolean;
  */
 export declare function peekDynamicUsage(): boolean;
 export declare function setHeadersAccessPhase(phase: HeadersAccessPhase): HeadersAccessPhase;
-export declare function getHeadersAccessPhase(): HeadersAccessPhase;
 /**
  * Set the headers/cookies context for the current RSC render.
  * Called by the framework's RSC entry before rendering each request.
@@ -151,6 +97,8 @@ export declare function hasEffectiveRequestCookieChanges(cookieHeader: string |
 export declare function applyEffectiveRequestCookieHeader(cookieHeader: string): void;
 /** Restore a middleware draft-mode transition inside a staged render scope. */
 export declare function restoreDraftModeTransition(cookieHeader: string): void;
+/** Replace request API inputs while retaining dynamic usage and pending mutations. */
+export declare function replaceHeadersContext(ctx: HeadersContext): void;
 export declare function setHeadersContext(ctx: HeadersContext | null): void;
 /**
  * Run a function with headers context, ensuring the context propagates
@@ -224,6 +172,8 @@ export declare function getAndClearPendingCookies(): string[];
  * Get any Set-Cookie header generated by draftMode().enable()/disable().
  * Called by the framework after rendering to attach the header to the response.
  */
+/** Check a pending draft transition without consuming its outgoing cookie. */
+export declare function hasDraftModeCookieHeader(): boolean;
 export declare function getDraftModeCookieHeader(): string | null;
 export declare function isDraftModeRequest(request: Request, draftModeSecret: string): boolean;
 /**
@@ -288,4 +238,4 @@ declare class RequestCookies {
   [SYNCHRONIZE_REQUEST_COOKIES](): void;
 }
 //#endregion
-export type { RequestCookies };
+export { type HeadersAccessPhase, type RenderDynamicLatch, type RequestCookies, type VinextHeadersShimState, createRenderDynamicLatch, getHeadersAccessPhase, isInsideAnyCacheScope, isRenderDynamicLatched, markDynamicUsage, markRenderRequestApiUsage, onRenderDynamicLatched, throwIfInsideCacheScope, throwIfStaticGenerationAccessError };