vinext 1.3.0 → 1.4.0

package/dist/shims/client-locale.js

@@ -3,7 +3,8 @@ import { detectDomainLocale, getLocalePathPrefix } from "../utils/domain-locale.
 //#region src/shims/client-locale.ts
 function getCurrentBrowserLocale({ basePath, domainLocales, hostname }) {
 	if (typeof window === "undefined") return void 0;
-	const pathnameLocale = getLocalePathPrefix(stripBasePath(window.location.pathname, basePath), window.__VINEXT_LOCALES__);
+	const locales = window.__VINEXT_LOCALES__;
+	const pathnameLocale = locales?.length ? getLocalePathPrefix(stripBasePath(window.location.pathname, basePath), locales) : void 0;
 	if (pathnameLocale) return pathnameLocale;
 	return detectDomainLocale(domainLocales, hostname ?? void 0)?.defaultLocale ?? window.__VINEXT_LOCALE__ ?? window.__VINEXT_DEFAULT_LOCALE__;
 }

package/dist/shims/client-page-root.d.ts

@@ -21,4 +21,5 @@ export type ClientPageRootProps = {
  */
 export declare function createClientPageSearchParams(searchParams: URLSearchParams | null | undefined): Promise<ClientPageSearchParams>;
 export declare function ClientPageRoot({ Component, pageProps, emptySearchParams }: ClientPageRootProps): import("react").ReactElement<Record<string, unknown>, string | import("react").JSXElementConstructor<any>>;
-//#endregion
+//#endregion
+export {};

package/dist/shims/client-page-root.js

@@ -1,10 +1,10 @@
 "use client";
 import { searchParamsToRecord } from "../utils/query.js";
 import { getNavigationContext } from "./navigation-context-state.js";
+import { getClientNavigationRenderContext, useSearchParams } from "./navigation.js";
 import "./navigation-server.js";
-import { isOwnPropertyCheck, isWellKnownProperty } from "./internal/thenable-well-known-properties.js";
 import { RenderedSearchContext } from "./slot.js";
-import { getClientNavigationRenderContext, useSearchParams } from "./navigation.js";
+import { isOwnPropertyCheck, isWellKnownProperty } from "./internal/thenable-well-known-properties.js";
 import { createElement, use, useMemo } from "react";
 //#region src/shims/client-page-root.tsx
 /**

package/dist/shims/config.d.ts

@@ -24,4 +24,5 @@ export declare function setConfig(configValue: RuntimeConfig): void;
  * Default export — matches `import getConfig from "next/config"`.
  */
 export default function getConfig(): RuntimeConfig;
-//#endregion
+//#endregion
+export {};

package/dist/shims/default-forbidden.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+//#region src/shims/default-forbidden.d.ts
+export default function DefaultForbidden(): React.ReactElement;
+//#endregion

package/dist/shims/default-forbidden.js

@@ -0,0 +1,18 @@
+import { HTTPAccessErrorFallback } from "./http-access-error-fallback.js";
+import React from "react";
+//#region src/shims/default-forbidden.tsx
+/**
+* Ported from Next.js's built-in default forbidden component:
+*   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/builtin/forbidden.tsx
+*
+* Rendered when `forbidden()` is called and no `app/forbidden.tsx` boundary
+* catches it.
+*/
+function DefaultForbidden() {
+	return React.createElement(HTTPAccessErrorFallback, {
+		status: 403,
+		message: "This page could not be accessed."
+	});
+}
+//#endregion
+export { DefaultForbidden as default };

package/dist/shims/default-not-found.d.ts

@@ -1,9 +1,4 @@
 import React from "react";
 //#region src/shims/default-not-found.d.ts
-/**
- * Mirrors `<HTTPAccessErrorFallback status={404} message="This page could not be found." />`
- * from Next.js. Kept in sync with the upstream component's structure so HTML
- * snapshot diffs between Next.js and vinext stay minimal.
- */
 export default function DefaultNotFound(): React.ReactElement;
 //#endregion

package/dist/shims/default-not-found.js

@@ -1,59 +1,23 @@
+import { HTTPAccessErrorFallback } from "./http-access-error-fallback.js";
 import React from "react";
 //#region src/shims/default-not-found.tsx
 /**
 * Ported from Next.js's built-in default not-found component:
 *   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/builtin/not-found.tsx
-*   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/http-access-fallback/error-fallback.tsx
 *
 * Rendered when an App Router request resolves to a 404 and the user has not
 * supplied their own `app/not-found.tsx` (or `app/global-not-found.tsx`).
-* Matches Next.js's `HTTPAccessErrorFallback` exactly: a centered 404 / message
-* pair with minified theme CSS and dark-mode media query.
 *
 * The message string `"This page could not be found."` (note the trailing
 * period) is the canonical body asserted by Next.js's deploy suite
 * (`test/e2e/app-dir/prefetching-not-found/prefetching-not-found.test.ts`,
 * `test/e2e/basepath/error-pages.test.ts`).
 */
-const styles = {
-	error: {
-		fontFamily: "system-ui,\"Segoe UI\",Roboto,Helvetica,Arial,sans-serif,\"Apple Color Emoji\",\"Segoe UI Emoji\"",
-		height: "100vh",
-		textAlign: "center",
-		display: "flex",
-		flexDirection: "column",
-		alignItems: "center",
-		justifyContent: "center"
-	},
-	desc: { display: "inline-block" },
-	h1: {
-		display: "inline-block",
-		margin: "0 20px 0 0",
-		padding: "0 23px 0 0",
-		fontSize: 24,
-		fontWeight: 500,
-		verticalAlign: "top",
-		lineHeight: "49px"
-	},
-	h2: {
-		fontSize: 14,
-		fontWeight: 400,
-		lineHeight: "49px",
-		margin: 0
-	}
-};
-const STATUS = 404;
-const MESSAGE = "This page could not be found.";
-/**
-* Mirrors `<HTTPAccessErrorFallback status={404} message="This page could not be found." />`
-* from Next.js. Kept in sync with the upstream component's structure so HTML
-* snapshot diffs between Next.js and vinext stay minimal.
-*/
 function DefaultNotFound() {
-	return React.createElement(React.Fragment, null, React.createElement("title", null, `${STATUS}: ${MESSAGE}`), React.createElement("div", { style: styles.error }, React.createElement("div", null, React.createElement("style", { dangerouslySetInnerHTML: { __html: "body{color:#000;background:#fff;margin:0}.next-error-h1{border-right:1px solid rgba(0,0,0,.3)}@media (prefers-color-scheme:dark){body{color:#fff;background:#000}.next-error-h1{border-right:1px solid rgba(255,255,255,.3)}}" } }), React.createElement("h1", {
-		className: "next-error-h1",
-		style: styles.h1
-	}, STATUS), React.createElement("div", { style: styles.desc }, React.createElement("h2", { style: styles.h2 }, MESSAGE)))));
+	return React.createElement(HTTPAccessErrorFallback, {
+		status: 404,
+		message: "This page could not be found."
+	});
 }
 //#endregion
 export { DefaultNotFound as default };

package/dist/shims/default-unauthorized.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+//#region src/shims/default-unauthorized.d.ts
+export default function DefaultUnauthorized(): React.ReactElement;
+//#endregion

package/dist/shims/default-unauthorized.js

@@ -0,0 +1,18 @@
+import { HTTPAccessErrorFallback } from "./http-access-error-fallback.js";
+import React from "react";
+//#region src/shims/default-unauthorized.tsx
+/**
+* Ported from Next.js's built-in default unauthorized component:
+*   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/builtin/unauthorized.tsx
+*
+* Rendered when `unauthorized()` is called and no `app/unauthorized.tsx`
+* boundary catches it.
+*/
+function DefaultUnauthorized() {
+	return React.createElement(HTTPAccessErrorFallback, {
+		status: 401,
+		message: "You're not authorized to access this page."
+	});
+}
+//#endregion
+export { DefaultUnauthorized as default };

package/dist/shims/dynamic.js

@@ -89,9 +89,11 @@ function createElementWithProps(Component, props) {
 }
 /**
 * Lightweight error boundary that renders the loading component with the error
-* when a dynamic() loader rejects. Without this, loader failures would propagate
-* uncaught through React's rendering — this preserves the Next.js behavior where
-* the `loading` component can display errors.
+* when a dynamic() loader rejects, as the Pages Router's react-loadable does by
+* passing `error` to `loading`. App Router trees never get it: Next.js's App
+* Router next/dynamic is React.lazy inside Suspense with no boundary of its own,
+* so loader and render errors reach the nearest error.tsx.
+* https://github.com/vercel/next.js/blob/canary/packages/next/src/shared/lib/lazy-dynamic/loadable.tsx
 *
 * Lazily created because React.Component is not available in the RSC environment
 * (server components use a slimmed-down React that doesn't include class components).
@@ -202,6 +204,7 @@ function dynamic(dynamicInput, options) {
 		}
 		const InitialLazyComponent = createLazyComponent(loader);
 		const ClientSSRFalse = (props) => {
+			const isAppRouterTree = useIsAppRouterTree();
 			const [mounted, setMounted] = React.useState(false);
 			const { LazyComponent, retry, retryKey } = useRetryableLazyComponent(loader, InitialLazyComponent);
 			React.useEffect(() => setMounted(true), []);
@@ -209,7 +212,7 @@ function dynamic(dynamicInput, options) {
 			const fallback = LoadingComponent ? React.createElement(LoadingComponent, createDynamicLoadingProps({ retry })) : null;
 			const lazyElement = createElementWithProps(LazyComponent, props);
 			let content = lazyElement;
-			if (LoadingComponent) {
+			if (LoadingComponent && !isAppRouterTree) {
 				const ErrorBoundary = getDynamicErrorBoundary();
 				if (ErrorBoundary) content = React.createElement(ErrorBoundary, {
 					fallback: LoadingComponent,
@@ -237,7 +240,7 @@ function dynamic(dynamicInput, options) {
 			const fallback = LoadingComponent ? React.createElement(LoadingComponent, createDynamicLoadingProps()) : null;
 			const lazyElement = createElementWithProps(LazyServer, props);
 			let content = lazyElement;
-			if (LoadingComponent) {
+			if (LoadingComponent && !isAppRouterTree) {
 				const ErrorBoundary = getDynamicErrorBoundary();
 				if (ErrorBoundary) content = React.createElement(ErrorBoundary, {
 					fallback: LoadingComponent,
@@ -257,7 +260,7 @@ function dynamic(dynamicInput, options) {
 		const fallback = LoadingComponent ? React.createElement(LoadingComponent, createDynamicLoadingProps({ retry })) : null;
 		const lazyElement = createElementWithProps(LazyComponent, props);
 		let content = lazyElement;
-		if (LoadingComponent) {
+		if (LoadingComponent && !isAppRouterTree) {
 			const ErrorBoundary = getDynamicErrorBoundary();
 			if (ErrorBoundary) content = React.createElement(ErrorBoundary, {
 				fallback: LoadingComponent,

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

@@ -78,12 +78,47 @@ type NotFoundBoundaryProps = {
   fallback: React.ReactNode;
   children: React.ReactNode;
   resetKey?: string | null;
+  /** A parallel slot boundary's id, which the document may render caught. */
+  caughtId?: string;
 };
+type NotFoundBoundaryInnerProps = {
+  pathname: string | null;
+  initiallyNotFound?: boolean;
+} & NotFoundBoundaryProps;
+type NotFoundBoundaryState = {
+  notFound: boolean;
+  previousPathname: string | null;
+  previousResetKey: string | null;
+};
+/**
+ * Inner class component that catches notFound() errors and renders the
+ * not-found.tsx fallback. Resets when the pathname or the caller's segment
+ * reset key changes.
+ *
+ * The ErrorBoundary above re-throws notFound errors so they propagate up to this
+ * boundary. This must be placed above the ErrorBoundary in the component tree.
+ */
+export declare class NotFoundBoundaryInner extends React.Component<NotFoundBoundaryInnerProps, NotFoundBoundaryState> {
+  constructor(props: NotFoundBoundaryInnerProps);
+  componentDidMount(): void;
+  static getDerivedStateFromProps(props: NotFoundBoundaryInnerProps, state: NotFoundBoundaryState): NotFoundBoundaryState | null;
+  static getDerivedStateFromError(error: unknown): Partial<NotFoundBoundaryState>;
+  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;
+}
+/**
+ * Fallback for a page-level access boundary whose file belongs to an ancestor
+ * layout. Rethrowing from the fallback hands the signal to the next boundary
+ * up, so that layout's copy renders in place of the layouts below it while the
+ * page-level boundary keeps the element shape sibling routes share.
+ */
+export declare function HttpAccessFallbackPassthrough({ status }: {
+  status: 401 | 403 | 404;
+}): never;
 /**
  * Wrapper that reads the current pathname and passes it to the inner class
- * component. Segment reset keys own App Router remount semantics when present.
+ * component.
  */
-export declare function NotFoundBoundary({ fallback, children, resetKey }: NotFoundBoundaryProps): React.JSX.Element;
+export declare function NotFoundBoundary({ fallback, children, resetKey, caughtId }: NotFoundBoundaryProps): React.JSX.Element;
 type ForbiddenBoundaryProps = {
   fallback: React.ReactNode;
   children: React.ReactNode;
@@ -144,4 +179,5 @@ export declare class DevRecoveryBoundary extends React.Component<DevRecoveryBoun
   componentDidCatch(): void;
   render(): React.ReactNode;
 }
-//#endregion
+//#endregion
+export {};

package/dist/shims/error-boundary.js

@@ -1,11 +1,12 @@
 "use client";
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
-import { decodeRedirectError, isRedirectError } from "./navigation-errors.js";
+import { handleAppNavigationFailure } from "../client/app-nav-failure-handler.js";
+import { VINEXT_DEV_ERROR_RECOVERY_EVENT } from "../utils/dev-error-recovery-event.js";
+import { decodeRedirectError, forbidden, isRedirectError, notFound, unauthorized } from "./navigation-errors.js";
 import "./navigation-server.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";
+import { consumeCaughtNotFoundBoundary, useCaughtNotFoundBoundary } from "./caught-not-found-boundaries.js";
 import React from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 //#region src/shims/error-boundary.tsx
@@ -29,11 +30,8 @@ function readBoundaryResetState(props) {
 		previousResetKey: normalizeBoundaryResetKey(props.resetKey)
 	};
 }
-function shouldResetBoundary(nextResetState, previousResetState) {
-	const nextResetKey = normalizeBoundaryResetKey(nextResetState.previousResetKey);
-	const previousResetKey = normalizeBoundaryResetKey(previousResetState.previousResetKey);
-	if (nextResetKey !== null || previousResetKey !== null) return nextResetKey !== previousResetKey;
-	return nextResetState.previousPathname !== previousResetState.previousPathname;
+function shouldResetSegmentBoundary(nextResetState, previousResetState) {
+	return nextResetState.previousPathname !== previousResetState.previousPathname || normalizeBoundaryResetKey(nextResetState.previousResetKey) !== normalizeBoundaryResetKey(previousResetState.previousResetKey);
 }
 function addDevErrorRecoveryListener(listener) {
 	if (typeof window === "undefined") return;
@@ -136,7 +134,7 @@ var ErrorBoundaryInner = class extends React.Component {
 			error: null,
 			...nextResetState
 		};
-		if (state.error && shouldResetBoundary(nextResetState, state)) return {
+		if (state.error && shouldResetSegmentBoundary(nextResetState, state)) return {
 			error: null,
 			...nextResetState
 		};
@@ -196,8 +194,8 @@ function GlobalErrorBoundary({ fallback, children }) {
 }
 /**
 * Inner class component that catches notFound() errors and renders the
-* not-found.tsx fallback. Resets on the caller's segment reset key when one is
-* provided, otherwise falls back to pathname changes for legacy callers.
+* not-found.tsx fallback. Resets when the pathname or the caller's segment
+* reset key changes.
 *
 * The ErrorBoundary above re-throws notFound errors so they propagate up to this
 * boundary. This must be placed above the ErrorBoundary in the component tree.
@@ -206,13 +204,16 @@ var NotFoundBoundaryInner = class extends React.Component {
 	constructor(props) {
 		super(props);
 		this.state = {
-			notFound: false,
+			notFound: props.initiallyNotFound === true,
 			...readBoundaryResetState(props)
 		};
 	}
+	componentDidMount() {
+		if (this.props.initiallyNotFound === true) consumeCaughtNotFoundBoundary(this.props.caughtId);
+	}
 	static getDerivedStateFromProps(props, state) {
 		const nextResetState = readBoundaryResetState(props);
-		if (state.notFound && shouldResetBoundary(nextResetState, state)) return {
+		if (state.notFound && shouldResetSegmentBoundary(nextResetState, state)) return {
 			notFound: false,
 			...nextResetState
 		};
@@ -237,15 +238,29 @@ var NotFoundBoundaryInner = class extends React.Component {
 	}
 };
 /**
+* Fallback for a page-level access boundary whose file belongs to an ancestor
+* layout. Rethrowing from the fallback hands the signal to the next boundary
+* up, so that layout's copy renders in place of the layouts below it while the
+* page-level boundary keeps the element shape sibling routes share.
+*/
+function HttpAccessFallbackPassthrough({ status }) {
+	if (status === 403) forbidden();
+	if (status === 401) unauthorized();
+	notFound();
+}
+/**
 * Wrapper that reads the current pathname and passes it to the inner class
-* component. Segment reset keys own App Router remount semantics when present.
+* component.
 */
-function NotFoundBoundary({ fallback, children, resetKey }) {
+function NotFoundBoundary({ fallback, children, resetKey, caughtId }) {
 	const pathname = useErrorBoundaryPathname();
+	const initiallyNotFound = useCaughtNotFoundBoundary(caughtId);
 	return /* @__PURE__ */ jsx(NotFoundBoundaryInner, {
 		pathname,
 		resetKey,
 		fallback,
+		caughtId,
+		initiallyNotFound,
 		children
 	});
 }
@@ -259,7 +274,7 @@ var ForbiddenBoundaryInner = class extends React.Component {
 	}
 	static getDerivedStateFromProps(props, state) {
 		const nextResetState = readBoundaryResetState(props);
-		if (state.forbidden && shouldResetBoundary(nextResetState, state)) return {
+		if (state.forbidden && shouldResetSegmentBoundary(nextResetState, state)) return {
 			forbidden: false,
 			...nextResetState
 		};
@@ -301,7 +316,7 @@ var UnauthorizedBoundaryInner = class extends React.Component {
 	}
 	static getDerivedStateFromProps(props, state) {
 		const nextResetState = readBoundaryResetState(props);
-		if (state.unauthorized && shouldResetBoundary(nextResetState, state)) return {
+		if (state.unauthorized && shouldResetSegmentBoundary(nextResetState, state)) return {
 			unauthorized: false,
 			...nextResetState
 		};
@@ -374,4 +389,4 @@ var DevRecoveryBoundary = class extends React.Component {
 	}
 };
 //#endregion
-export { DevRecoveryBoundary, ErrorBoundary, ErrorBoundaryInner, ForbiddenBoundary, ForbiddenBoundaryInner, GlobalErrorBoundary, NotFoundBoundary, RedirectBoundary, RedirectErrorBoundary, SerializedErrorBoundary, UnauthorizedBoundary, UnauthorizedBoundaryInner };
+export { DevRecoveryBoundary, ErrorBoundary, ErrorBoundaryInner, ForbiddenBoundary, ForbiddenBoundaryInner, GlobalErrorBoundary, HttpAccessFallbackPassthrough, NotFoundBoundary, NotFoundBoundaryInner, RedirectBoundary, RedirectErrorBoundary, SerializedErrorBoundary, UnauthorizedBoundary, UnauthorizedBoundaryInner };

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

@@ -11,12 +11,16 @@ export type FetchDedupeEntry = {
   response: Response | null;
 };
 export type FetchCacheState = {
-  cacheableFetchUrls: Set<string>;
   currentRequestTags: string[];
   currentFetchSoftTags: string[];
   currentFetchCacheMode: FetchCacheMode | null;
   currentFetchRevalidate: number | null;
   currentForceDynamicFetchDefault: boolean;
+  /**
+   * Pages Router preview/draft render. App Router draft state is read from the
+   * headers context instead; Pages renders don't have one.
+   */
+  isDraftMode: boolean;
   dynamicFetchUrls: Set<string>;
   refreshStaleFetchesInForeground: boolean;
   isFetchDedupeActive: boolean;

package/dist/shims/fetch-cache-state.js

@@ -11,12 +11,12 @@ const _FALLBACK_KEY = Symbol.for("vinext.fetchCache.fallback");
 const fetchCacheAls = getOrCreateAls("vinext.fetchCache.als");
 function createFetchCacheState() {
 	return {
-		cacheableFetchUrls: /* @__PURE__ */ new Set(),
 		currentRequestTags: [],
 		currentFetchSoftTags: [],
 		currentFetchCacheMode: null,
 		currentFetchRevalidate: null,
 		currentForceDynamicFetchDefault: false,
+		isDraftMode: false,
 		dynamicFetchUrls: /* @__PURE__ */ new Set(),
 		refreshStaleFetchesInForeground: false,
 		isFetchDedupeActive: false,
@@ -77,13 +77,11 @@ function getCurrentFetchSoftTags() {
 */
 function runWithDetachedFetchObservations(fn) {
 	if (isInsideUnifiedScope()) return runWithUnifiedStateMutation((uCtx) => {
-		uCtx.cacheableFetchUrls = /* @__PURE__ */ new Set();
 		uCtx.currentRequestTags = [];
 		uCtx.dynamicFetchUrls = /* @__PURE__ */ new Set();
 	}, fn);
 	return fetchCacheAls.run({
 		...getFetchCacheState(),
-		cacheableFetchUrls: /* @__PURE__ */ new Set(),
 		currentRequestTags: [],
 		dynamicFetchUrls: /* @__PURE__ */ new Set()
 	}, fn);

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

@@ -11,7 +11,6 @@ declare global {
 }
 /** @internal Reset dedup state — exposed for test isolation only. */
 export declare function _resetPendingRefetches(): void;
-export declare function peekCacheableFetchObservations(): string[];
 export declare function peekDynamicFetchObservations(): string[];
 export declare function consumeDynamicFetchObservations(): string[];
 /**
@@ -31,6 +30,8 @@ export declare function setCurrentFetchSoftTags(tags: string[]): void;
 export declare function setCurrentFetchCacheMode(mode: FetchCacheMode | null): void;
 export declare function setCurrentFetchRevalidate(revalidate: number | null): void;
 export declare function setCurrentForceDynamicFetchDefault(enabled: boolean): void;
+/** Mark the current Pages Router render as a preview/draft render. */
+export declare function setCurrentFetchDraftMode(enabled: boolean): void;
 export declare function setRefreshStaleFetchesInForeground(enabled: boolean): void;
 /**
  * Install the patched fetch and reset per-request tag state.

package/dist/shims/fetch-cache.js

@@ -6,8 +6,8 @@ import { sha256Hex } from "../utils/hash.js";
 import { traceAppFetch } from "../server/app-fetch-tracing.js";
 import { addCollectedRequestTags, fallbackFetchCacheState, fetchCacheAls, getCurrentFetchSoftTags, getFetchCacheState, resetFallbackFetchCacheState, runWithDetachedFetchObservations } from "./fetch-cache-state.js";
 import { isInsideAnyCacheScope, markDynamicUsage } from "./internal/headers-state.js";
-import { getHeadersContext } from "./headers.js";
-import { _hasPendingRevalidatedTag, _setRequestScopedCacheLife } from "./cache-request-state.js";
+import { getHeadersContext, isDraftModeEnabled } from "./headers.js";
+import { _hasPendingRevalidatedTag, _isOnDemandRevalidate, _setRequestScopedCacheLife } from "./cache-request-state.js";
 import { Buffer } from "node:buffer";
 //#region src/shims/fetch-cache.ts
 /**
@@ -463,9 +463,6 @@ function markUncachedFetchForPageOutput(input) {
 	if (getHeadersContext()?.forceStatic !== true) getFetchCacheState().currentFetchRevalidate = 0;
 	markDynamicUsage();
 }
-function recordCacheableFetchObservation(input) {
-	getFetchCacheState().cacheableFetchUrls.add(getFetchObservationUrl(input));
-}
 function recordFiniteFetchRevalidate(revalidateSeconds) {
 	if (Number.isFinite(revalidateSeconds) && revalidateSeconds > 0) _setRequestScopedCacheLife({ revalidate: revalidateSeconds });
 }
@@ -503,7 +500,8 @@ async function writeFetchCacheResponse(handler, cacheKey, response, tags, revali
 	await handler.set(cacheKey, cacheValue, {
 		fetchCache: true,
 		tags,
-		revalidate: revalidateSeconds
+		revalidate: revalidateSeconds,
+		...options?.staleEntry ? { staleEntry: options.staleEntry } : {}
 	});
 }
 async function lowerFetchCacheRevalidateIfNeeded(handler, cacheKey, cachedValue, tags, revalidateSeconds) {
@@ -520,9 +518,6 @@ async function lowerFetchCacheRevalidateIfNeeded(handler, cacheKey, cachedValue,
 		revalidate: revalidateSeconds
 	});
 }
-function peekCacheableFetchObservations() {
-	return [...getFetchCacheState().cacheableFetchUrls].sort();
-}
 function peekDynamicFetchObservations() {
 	return [...getFetchCacheState().dynamicFetchUrls].sort();
 }
@@ -559,6 +554,10 @@ function setCurrentFetchRevalidate(revalidate) {
 function setCurrentForceDynamicFetchDefault(enabled) {
 	getFetchCacheState().currentForceDynamicFetchDefault = enabled;
 }
+/** Mark the current Pages Router render as a preview/draft render. */
+function setCurrentFetchDraftMode(enabled) {
+	getFetchCacheState().isDraftMode = enabled;
+}
 function setRefreshStaleFetchesInForeground(enabled) {
 	getFetchCacheState().refreshStaleFetchesInForeground = enabled;
 }
@@ -705,8 +704,12 @@ function dedupeFetch(input, init) {
 */
 function createPatchedFetch() {
 	const patchedFetch = async function patchedFetch(input, init, span) {
-		const nextOpts = init?.next;
 		const state = getFetchCacheState();
+		if (state.isDraftMode || isDraftModeEnabled()) {
+			recordDynamicFetchObservation(input);
+			return dedupeFetch(input, init);
+		}
+		const nextOpts = init?.next;
 		const fetchIdx = isInsideUnifiedScope() || fetchCacheAls.getStore() !== void 0 || fallbackFetchCacheState.isFetchDedupeActive ? (state.nextFetchId ?? 1) + 1 : void 0;
 		if (fetchIdx !== void 0) state.nextFetchId = fetchIdx;
 		const recordFetchOutcome = (response, cacheStatus, cacheReason) => {
@@ -753,7 +756,6 @@ function createPatchedFetch() {
 			return recordFetchOutcome(await dedupeFetch(input, cleanInit), "skip", "auto no cache");
 		}
 		const cacheReason = fetchCacheMode === "force-cache" || fetchCacheMode === "default-cache" ? `fetchCache = ${fetchCacheMode}` : `revalidate: ${nextOpts?.revalidate === false || cacheDirective === "force-cache" ? 4294967294 : revalidateSeconds}`;
-		recordCacheableFetchObservation(input);
 		if (typeof nextOpts?.revalidate === "number" && nextOpts.revalidate > 0) {
 			lowerCurrentFetchRevalidate(nextOpts.revalidate);
 			recordFiniteFetchRevalidate(nextOpts.revalidate);
@@ -785,8 +787,9 @@ function createPatchedFetch() {
 		}
 		const handler = getDataCacheHandler();
 		let mustBypassPendingRevalidation = _hasPendingRevalidatedTag([...tags, ...softTags]);
+		let staleEntry;
 		try {
-			let cached = mustBypassPendingRevalidation ? null : await handler.get(cacheKey, {
+			let cached = mustBypassPendingRevalidation || _isOnDemandRevalidate() ? null : await handler.get(cacheKey, {
 				kind: "FETCH",
 				tags,
 				softTags,
@@ -806,15 +809,19 @@ function createPatchedFetch() {
 				return recordFetchOutcome(buildCachedFetchResponse(cachedData, input), "hit", cacheReason);
 			}
 			if (cached?.value && cached.value.kind === "FETCH" && cached.cacheState === "stale") {
+				staleEntry = cached;
 				if (shouldRefreshStaleFetchInForeground()) {
 					const freshResponse = await dedupeFetch(input, fetchInit);
-					await writeFetchCacheResponse(handler, cacheKey, freshResponse, tags, revalidateSeconds);
+					await writeFetchCacheResponse(handler, cacheKey, freshResponse, tags, revalidateSeconds, { staleEntry: cached });
 					return recordFetchOutcome(freshResponse, "miss", cacheReason);
 				}
 				const staleData = cached.value.data;
 				if (!pendingRefetches.has(cacheKey)) {
 					const refetchPromise = originalFetch(input, fetchInit).then(async (freshResp) => {
-						await writeFetchCacheResponse(handler, cacheKey, freshResp, tags, revalidateSeconds, { cloneForReturn: false });
+						await writeFetchCacheResponse(handler, cacheKey, freshResp, tags, revalidateSeconds, {
+							cloneForReturn: false,
+							staleEntry: cached
+						});
 					}).catch((err) => {
 						const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
 						console.error(`[vinext] fetch cache background revalidation failed for ${url} (key=${cacheKey.slice(0, 12)}...):`, err);
@@ -835,13 +842,17 @@ function createPatchedFetch() {
 		}
 		const response = await (mustBypassPendingRevalidation ? originalFetch(input, fetchInit) : dedupeFetch(input, fetchInit));
 		const cacheValue = await buildFetchCacheValue(response, tags, revalidateSeconds);
-		if (cacheValue) handler.set(cacheKey, cacheValue, {
-			fetchCache: true,
-			tags,
-			revalidate: revalidateSeconds
-		}).catch((err) => {
-			console.error("[vinext] fetch cache write error:", err);
-		});
+		if (cacheValue) {
+			const write = handler.set(cacheKey, cacheValue, {
+				fetchCache: true,
+				tags,
+				revalidate: revalidateSeconds,
+				...staleEntry ? { staleEntry } : {}
+			}).catch((err) => {
+				console.error("[vinext] fetch cache write error:", err);
+			});
+			getRequestExecutionContext()?.waitUntil(write);
+		}
 		return recordFetchOutcome(response, "miss", cacheReason);
 	};
 	return ((input, init) => {
@@ -894,7 +905,6 @@ function withFetchCache() {
 async function runWithFetchCache(fn) {
 	_ensurePatchInstalled();
 	if (isInsideUnifiedScope()) return await runWithUnifiedStateMutation((uCtx) => {
-		uCtx.cacheableFetchUrls = /* @__PURE__ */ new Set();
 		uCtx.currentRequestTags = [];
 		uCtx.currentFetchSoftTags = [];
 		uCtx.dynamicFetchUrls = /* @__PURE__ */ new Set();
@@ -904,12 +914,12 @@ async function runWithFetchCache(fn) {
 		uCtx.nextFetchId = 1;
 	}, fn);
 	return fetchCacheAls.run({
-		cacheableFetchUrls: /* @__PURE__ */ new Set(),
 		currentRequestTags: [],
 		currentFetchSoftTags: [],
 		currentFetchCacheMode: null,
 		currentFetchRevalidate: null,
 		currentForceDynamicFetchDefault: false,
+		isDraftMode: false,
 		dynamicFetchUrls: /* @__PURE__ */ new Set(),
 		refreshStaleFetchesInForeground: false,
 		isFetchDedupeActive: true,
@@ -950,4 +960,4 @@ function getOriginalFetch() {
 	return originalFetch;
 }
 //#endregion
-export { _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getCurrentFetchSoftTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithDetachedFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchRevalidate, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault, setRefreshStaleFetchesInForeground, withFetchCache };
+export { _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getCurrentFetchSoftTags, getOriginalFetch, peekDynamicFetchObservations, runWithDetachedFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchDraftMode, setCurrentFetchRevalidate, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault, setRefreshStaleFetchesInForeground, withFetchCache };

package/dist/shims/font-google.js

@@ -1,2 +1 @@
-import googleFonts, { buildGoogleFontsUrl, createFontLoader, getSSRFontLinks, getSSRFontPreloads, getSSRFontStyles } from "./font-google-base.js";
-export { buildGoogleFontsUrl, createFontLoader, googleFonts as default, getSSRFontLinks, getSSRFontPreloads, getSSRFontStyles };
+export { buildGoogleFontsUrl, createFontLoader, default, getSSRFontLinks, getSSRFontPreloads, getSSRFontStyles } from "./font-google-base.js";

package/dist/shims/font-utils.d.ts

@@ -47,9 +47,10 @@ export declare function resolveGoogleFontStyle(style: string | string[] | undefi
 export declare function resolveSingleFaceStyle(input: FontFaceStyleInput): FontStyle;
 export declare function formatFontClassRule(className: string, style: FontStyle): string;
 /**
- * Determine the MIME type for a font file based on its extension.
+ * Determine the preload `type` for a font file based on its extension.
  * Uses endsWith() only to avoid false positives from substring matches
- * (e.g. ".woff" matching ".woff2").
+ * (e.g. ".woff" matching ".woff2"). Matches Next.js, which emits
+ * `font/${ext}` for every font preload (including `font/eot`).
  */
 export declare function getFontMimeType(pathOrUrl: string): string;
 //#endregion