vinext 1.0.0-beta.8 → 1.0.0

package/dist/shims/dynamic.d.ts

@@ -7,8 +7,8 @@ type DynamicInput<P> = DynamicOptions<P> | Loader<P>;
  * rendering. Dynamic imports now use React.lazy + Suspense, so there is no
  * separate preload work to await.
  */
-declare function flushPreloads(): Promise<void[]>;
+export declare function flushPreloads(): Promise<void[]>;
 declare function dynamic<P = {}>(dynamicInput: DynamicInput<P>, options?: DynamicOptions<P>): ComponentType<P>;
-declare function noSSR<P = {}>(LoadableInitializer: LoadableFn<P>, loadableOptions: DynamicOptions<P>): React.ComponentType<P>;
+export declare function noSSR<P = {}>(LoadableInitializer: LoadableFn<P>, loadableOptions: DynamicOptions<P>): React.ComponentType<P>;
 //#endregion
-export { type DynamicOptions, type DynamicOptionsLoadingProps, type LoadableComponent, type LoadableFn, type LoadableGeneratedOptions, type LoadableOptions, type Loader, type LoaderComponent, type LoaderMap, dynamic as default, flushPreloads, noSSR };
+export { type DynamicOptions, type DynamicOptionsLoadingProps, type LoadableComponent, type LoadableFn, type LoadableGeneratedOptions, type LoadableOptions, type Loader, type LoaderComponent, type LoaderMap, dynamic as default };

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

@@ -1,6 +1,5 @@
 import { AppRouterInstance } from "./internal/app-router-context.js";
 //#region src/shims/error-boundary-navigation.d.ts
-declare function useErrorBoundaryPathname(): string;
-declare function useErrorBoundaryRouter(): AppRouterInstance;
-//#endregion
-export { useErrorBoundaryPathname, useErrorBoundaryRouter };
+export declare function useErrorBoundaryPathname(): string;
+export declare function useErrorBoundaryRouter(): AppRouterInstance;
+//#endregion

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

@@ -1,6 +1,6 @@
 import React from "react";
 //#region src/shims/error-boundary.d.ts
-type ErrorBoundaryProps = {
+export type ErrorBoundaryProps = {
   fallback: React.ComponentType<{
     error: unknown;
     reset: () => void;
@@ -8,13 +8,13 @@ type ErrorBoundaryProps = {
   children: React.ReactNode;
   resetKey?: string | null;
 };
-type SerializedBoundaryError = {
+export type SerializedBoundaryError = {
   digest?: string;
   message: string;
   name?: string;
   stack?: string;
 };
-declare function SerializedErrorBoundary({ fallback: Fallback, error }: {
+export declare function SerializedErrorBoundary({ fallback: Fallback, error }: {
   fallback: React.ComponentType<{
     error: Error & {
       digest?: string;
@@ -34,12 +34,12 @@ type ErrorBoundaryInnerProps = {
   isImplicitRootErrorBoundary?: boolean;
   pathname: string | null;
 } & ErrorBoundaryProps;
-type ErrorBoundaryState = {
+export type ErrorBoundaryState = {
   error: CapturedError | null;
   previousPathname: string | null;
   previousResetKey: string | null;
 };
-declare class RedirectErrorBoundary extends React.Component<{
+export declare class RedirectErrorBoundary extends React.Component<{
   children?: React.ReactNode;
 }, RedirectBoundaryState> {
   constructor(props: {
@@ -48,7 +48,7 @@ declare class RedirectErrorBoundary extends React.Component<{
   static getDerivedStateFromError(error: unknown): RedirectBoundaryState;
   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;
 }
-declare function RedirectBoundary({ children }: {
+export declare function RedirectBoundary({ children }: {
   children?: React.ReactNode;
 }): React.JSX.Element;
 /**
@@ -56,7 +56,7 @@ declare function RedirectBoundary({ children }: {
  * This must be a client component since error boundaries use
  * componentDidCatch / getDerivedStateFromError.
  */
-declare class ErrorBoundaryInner extends React.Component<ErrorBoundaryInnerProps, ErrorBoundaryState> {
+export declare class ErrorBoundaryInner extends React.Component<ErrorBoundaryInnerProps, ErrorBoundaryState> {
   constructor(props: ErrorBoundaryInnerProps);
   static getDerivedStateFromProps(props: ErrorBoundaryInnerProps, state: ErrorBoundaryState): ErrorBoundaryState | null;
   static getDerivedStateFromError(error: unknown): Partial<ErrorBoundaryState>;
@@ -66,8 +66,8 @@ declare class ErrorBoundaryInner extends React.Component<ErrorBoundaryInnerProps
   reset: () => void;
   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;
 }
-declare function ErrorBoundary({ fallback, children, resetKey }: ErrorBoundaryProps): React.JSX.Element;
-declare function GlobalErrorBoundary({ fallback, children }: {
+export declare function ErrorBoundary({ fallback, children, resetKey }: ErrorBoundaryProps): React.JSX.Element;
+export declare function GlobalErrorBoundary({ fallback, children }: {
   fallback: React.ComponentType<{
     error: unknown;
     reset: () => void;
@@ -83,7 +83,7 @@ type NotFoundBoundaryProps = {
  * Wrapper that reads the current pathname and passes it to the inner class
  * component. Segment reset keys own App Router remount semantics when present.
  */
-declare function NotFoundBoundary({ fallback, children, resetKey }: NotFoundBoundaryProps): React.JSX.Element;
+export declare function NotFoundBoundary({ fallback, children, resetKey }: NotFoundBoundaryProps): React.JSX.Element;
 type ForbiddenBoundaryProps = {
   fallback: React.ReactNode;
   children: React.ReactNode;
@@ -97,13 +97,13 @@ type ForbiddenBoundaryState = {
   previousPathname: string | null;
   previousResetKey: string | null;
 };
-declare class ForbiddenBoundaryInner extends React.Component<ForbiddenBoundaryInnerProps, ForbiddenBoundaryState> {
+export declare class ForbiddenBoundaryInner extends React.Component<ForbiddenBoundaryInnerProps, ForbiddenBoundaryState> {
   constructor(props: ForbiddenBoundaryInnerProps);
   static getDerivedStateFromProps(props: ForbiddenBoundaryInnerProps, state: ForbiddenBoundaryState): ForbiddenBoundaryState | null;
   static getDerivedStateFromError(error: unknown): Partial<ForbiddenBoundaryState>;
   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;
 }
-declare function ForbiddenBoundary({ fallback, children, resetKey }: ForbiddenBoundaryProps): React.JSX.Element;
+export declare function ForbiddenBoundary({ fallback, children, resetKey }: ForbiddenBoundaryProps): React.JSX.Element;
 type UnauthorizedBoundaryProps = {
   fallback: React.ReactNode;
   children: React.ReactNode;
@@ -117,14 +117,14 @@ type UnauthorizedBoundaryState = {
   previousPathname: string | null;
   previousResetKey: string | null;
 };
-declare class UnauthorizedBoundaryInner extends React.Component<UnauthorizedBoundaryInnerProps, UnauthorizedBoundaryState> {
+export declare class UnauthorizedBoundaryInner extends React.Component<UnauthorizedBoundaryInnerProps, UnauthorizedBoundaryState> {
   constructor(props: UnauthorizedBoundaryInnerProps);
   static getDerivedStateFromProps(props: UnauthorizedBoundaryInnerProps, state: UnauthorizedBoundaryState): UnauthorizedBoundaryState | null;
   static getDerivedStateFromError(error: unknown): Partial<UnauthorizedBoundaryState>;
   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;
 }
-declare function UnauthorizedBoundary({ fallback, children, resetKey }: UnauthorizedBoundaryProps): React.JSX.Element;
-type DevRecoveryBoundaryProps = {
+export declare function UnauthorizedBoundary({ fallback, children, resetKey }: UnauthorizedBoundaryProps): React.JSX.Element;
+export type DevRecoveryBoundaryProps = {
   isImplicitRootErrorBoundary?: boolean;
   resetKey: number;
   onCatch?: (resetKey: number) => void;
@@ -134,7 +134,7 @@ type DevRecoveryBoundaryState = {
   error: CapturedError | null;
   previousResetKey: number;
 };
-declare class DevRecoveryBoundary extends React.Component<DevRecoveryBoundaryProps, DevRecoveryBoundaryState> {
+export declare class DevRecoveryBoundary extends React.Component<DevRecoveryBoundaryProps, DevRecoveryBoundaryState> {
   constructor(props: DevRecoveryBoundaryProps);
   static getDerivedStateFromProps(props: DevRecoveryBoundaryProps, state: DevRecoveryBoundaryState): DevRecoveryBoundaryState | null;
   static getDerivedStateFromError(error: unknown): Partial<DevRecoveryBoundaryState>;
@@ -144,5 +144,4 @@ declare class DevRecoveryBoundary extends React.Component<DevRecoveryBoundaryPro
   componentDidCatch(): void;
   render(): React.ReactNode;
 }
-//#endregion
-export { DevRecoveryBoundary, DevRecoveryBoundaryProps, ErrorBoundary, ErrorBoundaryInner, ErrorBoundaryProps, ErrorBoundaryState, ForbiddenBoundary, ForbiddenBoundaryInner, GlobalErrorBoundary, NotFoundBoundary, RedirectBoundary, RedirectErrorBoundary, SerializedBoundaryError, SerializedErrorBoundary, UnauthorizedBoundary, UnauthorizedBoundaryInner };
+//#endregion

package/dist/shims/error-boundary.js

@@ -1,21 +1,22 @@
 "use client";
+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 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 { isNavigationSignalError } from "../utils/navigation-signal.js";
 import React from "react";
 import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 //#region src/shims/error-boundary.tsx
 function SerializedErrorBoundary({ fallback: Fallback, error }) {
+	const reconstructedError = Object.assign(new Error(error.message), {
+		digest: error.digest,
+		name: error.name ?? "Error",
+		stack: error.stack
+	});
 	return /* @__PURE__ */ jsx(Fallback, {
-		error: Object.assign(new Error(error.message), {
-			digest: error.digest,
-			name: error.name ?? "Error",
-			stack: error.stack
-		}),
+		error: reconstructedError,
 		reset: () => globalThis.location?.reload()
 	});
 }
@@ -157,16 +158,18 @@ var ErrorBoundaryInner = class extends React.Component {
 	}
 };
 function ErrorBoundary({ fallback, children, resetKey }) {
+	const pathname = useErrorBoundaryPathname();
 	return /* @__PURE__ */ jsx(ErrorBoundaryInner, {
-		pathname: useErrorBoundaryPathname(),
+		pathname,
 		resetKey,
 		fallback,
 		children
 	});
 }
 function GlobalErrorBoundary({ fallback, children }) {
+	const pathname = useErrorBoundaryPathname();
 	return /* @__PURE__ */ jsx(ErrorBoundaryInner, {
-		pathname: useErrorBoundaryPathname(),
+		pathname,
 		fallback,
 		isImplicitRootErrorBoundary: fallback === DefaultGlobalError,
 		children
@@ -219,8 +222,9 @@ var NotFoundBoundaryInner = class extends React.Component {
 * component. Segment reset keys own App Router remount semantics when present.
 */
 function NotFoundBoundary({ fallback, children, resetKey }) {
+	const pathname = useErrorBoundaryPathname();
 	return /* @__PURE__ */ jsx(NotFoundBoundaryInner, {
-		pathname: useErrorBoundaryPathname(),
+		pathname,
 		resetKey,
 		fallback,
 		children
@@ -260,8 +264,9 @@ var ForbiddenBoundaryInner = class extends React.Component {
 	}
 };
 function ForbiddenBoundary({ fallback, children, resetKey }) {
+	const pathname = useErrorBoundaryPathname();
 	return /* @__PURE__ */ jsx(ForbiddenBoundaryInner, {
-		pathname: useErrorBoundaryPathname(),
+		pathname,
 		resetKey,
 		fallback,
 		children
@@ -301,8 +306,9 @@ var UnauthorizedBoundaryInner = class extends React.Component {
 	}
 };
 function UnauthorizedBoundary({ fallback, children, resetKey }) {
+	const pathname = useErrorBoundaryPathname();
 	return /* @__PURE__ */ jsx(UnauthorizedBoundaryInner, {
-		pathname: useErrorBoundaryPathname(),
+		pathname,
 		resetKey,
 		fallback,
 		children

package/dist/shims/error.d.ts

@@ -1,7 +1,7 @@
 import React from "react";
 import { IncomingMessage, ServerResponse } from "node:http";
 //#region src/shims/error.d.ts
-type ErrorProps = {
+export type ErrorProps = {
   statusCode: number;
   hostname?: string;
   title?: string;
@@ -21,7 +21,7 @@ declare class ErrorComponent<P = {}> extends React.Component<P & ErrorProps> {
   static origGetInitialProps: typeof getErrorInitialProps;
   render(): React.ReactElement;
 }
-type ErrorInfo = {
+export type ErrorInfo = {
   error: Error;
   reset: () => void;
   unstable_retry: () => void;
@@ -35,8 +35,8 @@ type _UserProps = Record<string, unknown>;
  * Ported from Next.js:
  *   https://github.com/vercel/next.js/blob/canary/packages/next/src/client/components/catch-error.tsx
  */
-declare function unstable_catchError<P extends _UserProps>(fallback: (props: P, errorInfo: ErrorInfo) => React.ReactNode): React.ComponentType<P & {
+export declare function unstable_catchError<P extends _UserProps>(fallback: (props: P, errorInfo: ErrorInfo) => React.ReactNode): React.ComponentType<P & {
   children?: React.ReactNode;
 }>;
 //#endregion
-export { ErrorInfo, ErrorProps, ErrorComponent as default, unstable_catchError };
+export { ErrorComponent as default };

package/dist/shims/error.js

@@ -1,8 +1,8 @@
 import { AppRouterContext } from "./internal/app-router-context.js";
 import { RouterContext } from "./internal/router-context.js";
 import { isNextRouterError } from "./navigation-errors.js";
-import Head from "./head.js";
 import "./navigation.js";
+import Head from "./head.js";
 import { useUntrackedPathname } from "./internal/navigation-untracked.js";
 import React from "react";
 //#region src/shims/error.tsx

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

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

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

@@ -34,8 +34,8 @@ declare global {
   }
 }
 /** @internal Reset dedup state — exposed for test isolation only. */
-declare function _resetPendingRefetches(): void;
-type FetchCacheState = {
+export declare function _resetPendingRefetches(): void;
+export type FetchCacheState = {
   cacheableFetchUrls: Set<string>;
   currentRequestTags: string[];
   currentFetchSoftTags: string[];
@@ -46,17 +46,18 @@ type FetchCacheState = {
   refreshStaleFetchesInForeground: boolean;
   isFetchDedupeActive: boolean;
   currentFetchDedupeEntries: Map<string, FetchDedupeEntry[]>;
+  nextFetchId: number;
 };
-type FetchCacheMode = "auto" | "default-cache" | "default-no-store" | "force-cache" | "force-no-store" | "only-cache" | "only-no-store";
-declare function peekCacheableFetchObservations(): string[];
-declare function peekDynamicFetchObservations(): string[];
-declare function consumeDynamicFetchObservations(): string[];
+export type FetchCacheMode = "auto" | "default-cache" | "default-no-store" | "force-cache" | "force-no-store" | "only-cache" | "only-no-store";
+export declare function peekCacheableFetchObservations(): string[];
+export declare function peekDynamicFetchObservations(): string[];
+export declare function consumeDynamicFetchObservations(): string[];
 /**
  * Get tags collected during the current render pass.
  * Useful for associating page-level cache entries with all the
  * fetch tags used during rendering.
  */
-declare function getCollectedFetchTags(): string[];
+export declare function getCollectedFetchTags(): string[];
 /**
  * Append cache tags to the current request's collected tags.
  *
@@ -69,7 +70,7 @@ declare function getCollectedFetchTags(): string[];
  * (issue #1453). Tags are already encoded by the caller; deduped to match the
  * tagged-fetch path. A no-op for empty input.
  */
-declare function addCollectedRequestTags(tags: readonly string[]): void;
+export declare function addCollectedRequestTags(tags: readonly string[]): void;
 /**
  * Set path-derived implicit tags for fetch cache reads in the current render.
  *
@@ -77,7 +78,7 @@ declare function addCollectedRequestTags(tags: readonly string[]): void;
  * `softTags`: `revalidatePath()` should make a fetch miss while rendering the
  * affected route, without permanently coupling a shared fetch entry to one path.
  */
-declare function setCurrentFetchSoftTags(tags: string[]): void;
+export declare function setCurrentFetchSoftTags(tags: string[]): void;
 /**
  * Read the path-derived soft tags for the current render.
  *
@@ -85,11 +86,11 @@ declare function setCurrentFetchSoftTags(tags: string[]): void;
  * so that `revalidatePath()` invalidates "use cache" entries during the
  * affected route's next request, even when the entry carries no hard tags.
  */
-declare function getCurrentFetchSoftTags(): string[];
-declare function setCurrentFetchCacheMode(mode: FetchCacheMode | null): void;
-declare function setCurrentFetchRevalidate(revalidate: number | null): void;
-declare function setCurrentForceDynamicFetchDefault(enabled: boolean): void;
-declare function setRefreshStaleFetchesInForeground(enabled: boolean): void;
+export declare function getCurrentFetchSoftTags(): string[];
+export declare function setCurrentFetchCacheMode(mode: FetchCacheMode | null): void;
+export declare function setCurrentFetchRevalidate(revalidate: number | null): void;
+export declare function setCurrentForceDynamicFetchDefault(enabled: boolean): void;
+export declare function setRefreshStaleFetchesInForeground(enabled: boolean): void;
 /**
  * Install the patched fetch and reset per-request tag state.
  * Returns a cleanup function that clears tags.
@@ -101,13 +102,13 @@ declare function setRefreshStaleFetchesInForeground(enabled: boolean): void;
  *   const cleanup = withFetchCache();
  *   try { await render(); } finally { cleanup(); }
  */
-declare function withFetchCache(): () => void;
+export declare function withFetchCache(): () => void;
 /**
  * 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.
  */
-declare function runWithFetchCache<T>(fn: () => Promise<T>): Promise<T>;
+export declare function runWithFetchCache<T>(fn: () => Promise<T>): Promise<T>;
 /**
  * Activate per-render fetch memoization without resetting request fetch tags.
  * Next.js request memoization is scoped to React render work, not the whole
@@ -120,8 +121,8 @@ declare function runWithFetchCache<T>(fn: () => Promise<T>): Promise<T>;
  * the parent already activated dedupe (the common dispatch case) but means
  * standalone callers must keep the dedupe scope alive across consumption.
  */
-declare function runWithFetchDedupe<T>(fn: () => T): T;
-declare function runWithFetchDedupe<T>(fn: () => Promise<T>): Promise<T>;
+export declare function runWithFetchDedupe<T>(fn: () => T): T;
+export declare function runWithFetchDedupe<T>(fn: () => Promise<T>): Promise<T>;
 /**
  * Install the patched fetch without creating a standalone ALS scope.
  *
@@ -130,11 +131,10 @@ declare function runWithFetchDedupe<T>(fn: () => Promise<T>): Promise<T>;
  * that isolation itself via `currentRequestTags`, so callers inside
  * `runWithRequestContext()` only need the process-global fetch monkey-patch.
  */
-declare function ensureFetchPatch(): void;
+export declare function ensureFetchPatch(): void;
 /**
  * Get the original (unpatched) fetch function.
  * Useful for internal code that should bypass caching.
  */
-declare function getOriginalFetch(): typeof globalThis.fetch;
-//#endregion
-export { FetchCacheMode, FetchCacheState, _resetPendingRefetches, addCollectedRequestTags, consumeDynamicFetchObservations, ensureFetchPatch, getCollectedFetchTags, getCurrentFetchSoftTags, getOriginalFetch, peekCacheableFetchObservations, peekDynamicFetchObservations, runWithFetchCache, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchRevalidate, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault, setRefreshStaleFetchesInForeground, withFetchCache };
+export declare function getOriginalFetch(): typeof globalThis.fetch;
+//#endregion

package/dist/shims/fetch-cache.js

@@ -3,7 +3,8 @@ import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation }
 import { getRequestExecutionContext } from "./request-context.js";
 import { getDataCacheHandler } from "./cache-handler.js";
 import { encodeCacheTags } from "../utils/encode-cache-tag.js";
-import { getHeadersContext, markDynamicUsage } from "./headers.js";
+import { traceAppFetch } from "../server/app-fetch-tracing.js";
+import { getHeadersContext, isInsideAnyCacheScope, markDynamicUsage } from "./headers.js";
 import { _hasPendingRevalidatedTag, _setRequestScopedCacheLife } from "./cache-request-state.js";
 import { Buffer } from "node:buffer";
 //#region src/shims/fetch-cache.ts
@@ -34,7 +35,7 @@ import { Buffer } from "node:buffer";
 */
 const HEADER_BLOCKLIST = ["traceparent", "tracestate"];
 const CACHE_KEY_PREFIX = "v5";
-const MAX_CACHE_KEY_BODY_BYTES = 1024 * 1024;
+const MAX_CACHE_KEY_BODY_BYTES = 1048576;
 const ONE_YEAR_SECONDS = 31536e3;
 var BodyTooLargeForCacheKeyError = class extends Error {
 	constructor() {
@@ -350,7 +351,8 @@ const _fallbackState = _g[_FALLBACK_KEY] ??= {
 	dynamicFetchUrls: /* @__PURE__ */ new Set(),
 	refreshStaleFetchesInForeground: false,
 	isFetchDedupeActive: false,
-	currentFetchDedupeEntries: /* @__PURE__ */ new Map()
+	currentFetchDedupeEntries: /* @__PURE__ */ new Map(),
+	nextFetchId: 1
 };
 function _getState() {
 	if (isInsideUnifiedScope()) return getRequestContext();
@@ -371,15 +373,21 @@ function _resetFallbackState(isFetchDedupeActive) {
 	_fallbackState.refreshStaleFetchesInForeground = false;
 	_fallbackState.isFetchDedupeActive = isFetchDedupeActive;
 	_fallbackState.currentFetchDedupeEntries = /* @__PURE__ */ new Map();
+	_fallbackState.nextFetchId = 1;
 }
 function getFetchObservationUrl(input) {
 	return typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
 }
-function recordDynamicFetchObservation(input) {
+function addDynamicFetchObservation(input) {
 	_getState().dynamicFetchUrls.add(getFetchObservationUrl(input));
 }
+function recordDynamicFetchObservation(input) {
+	if (isInsideAnyCacheScope()) return;
+	addDynamicFetchObservation(input);
+}
 function markUncachedFetchForPageOutput(input) {
-	recordDynamicFetchObservation(input);
+	if (isInsideAnyCacheScope()) return;
+	addDynamicFetchObservation(input);
 	if (getHeadersContext()?.forceStatic !== true) _getState().currentFetchRevalidate = 0;
 	markDynamicUsage();
 }
@@ -650,22 +658,35 @@ function dedupeFetch(input, init) {
 * 5. Respects `next.tags` for tag-based invalidation via revalidateTag()
 */
 function createPatchedFetch() {
-	return async function patchedFetch(input, init) {
+	const patchedFetch = async function patchedFetch(input, init, span) {
 		const nextOpts = init?.next;
-		const cacheDirective = resolveSegmentCacheDirective(getFetchCacheDirective(input, init), nextOpts, _getState().currentFetchCacheMode, _getState().currentForceDynamicFetchDefault);
+		const state = _getState();
+		const fetchIdx = isInsideUnifiedScope() || _als.getStore() !== void 0 || _fallbackState.isFetchDedupeActive ? (state.nextFetchId ?? 1) + 1 : void 0;
+		if (fetchIdx !== void 0) state.nextFetchId = fetchIdx;
+		const recordFetchOutcome = (response, cacheStatus, cacheReason) => {
+			if (fetchIdx !== void 0) span?.setAttributes({
+				"next.fetch.idx": fetchIdx,
+				"next.fetch.cache_status": cacheStatus,
+				"next.fetch.cache_reason": cacheReason
+			});
+			return response;
+		};
+		const fetchCacheMode = state.currentFetchCacheMode;
+		const cacheDirective = resolveSegmentCacheDirective(getFetchCacheDirective(input, init), nextOpts, fetchCacheMode, state.currentForceDynamicFetchDefault);
+		const skipReason = fetchCacheMode === "force-no-store" || fetchCacheMode === "only-no-store" || fetchCacheMode === "default-no-store" ? `fetchCache = ${fetchCacheMode}` : cacheDirective === "no-store" || cacheDirective === "no-cache" ? `cache: ${cacheDirective}` : nextOpts?.revalidate === 0 ? "revalidate: 0" : "auto no cache";
 		if (!nextOpts && !cacheDirective) {
 			recordDynamicFetchObservation(input);
-			return dedupeFetch(input, init);
+			return recordFetchOutcome(await dedupeFetch(input, init), "skip", "auto no cache");
 		}
 		if (cacheDirective === "no-store" || cacheDirective === "no-cache" || nextOpts?.revalidate === 0) {
 			const cleanInit = stripNextFromInit(init, cacheDirective);
 			markUncachedFetchForPageOutput(input);
-			return dedupeFetch(input, cleanInit);
+			return recordFetchOutcome(await dedupeFetch(input, cleanInit), "skip", skipReason);
 		}
 		if (!(cacheDirective === "force-cache" || nextOpts?.revalidate === false || typeof nextOpts?.revalidate === "number" && nextOpts.revalidate > 0) && hasAuthHeaders(input, init)) {
 			const cleanInit = stripNextFromInit(init, cacheDirective);
 			recordDynamicFetchObservation(input);
-			return dedupeFetch(input, cleanInit);
+			return recordFetchOutcome(await dedupeFetch(input, cleanInit), "skip", "auto no cache");
 		}
 		let revalidateSeconds;
 		if (cacheDirective === "force-cache") revalidateSeconds = nextOpts?.revalidate && typeof nextOpts.revalidate === "number" ? nextOpts.revalidate : ONE_YEAR_SECONDS;
@@ -676,17 +697,20 @@ function createPatchedFetch() {
 			if (routeRevalidate === 0) {
 				const cleanInit = stripNextFromInit(init, cacheDirective);
 				markUncachedFetchForPageOutput(input);
-				return dedupeFetch(input, cleanInit);
+				return recordFetchOutcome(await dedupeFetch(input, cleanInit), "skip", "revalidate: 0");
 			}
 			revalidateSeconds = routeRevalidate === null || routeRevalidate === Infinity ? ONE_YEAR_SECONDS : routeRevalidate;
 		} else {
 			const cleanInit = stripNextFromInit(init, cacheDirective);
 			recordDynamicFetchObservation(input);
-			return dedupeFetch(input, cleanInit);
+			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(revalidateSeconds);
+		if (typeof nextOpts?.revalidate === "number" && nextOpts.revalidate > 0) {
+			lowerCurrentFetchRevalidate(nextOpts.revalidate);
+			recordFiniteFetchRevalidate(nextOpts.revalidate);
+		}
 		const reqTags = _getState().currentRequestTags;
 		const tags = encodeCacheTags(nextOpts?.tags ?? []);
 		if (tags.length > 0) {
@@ -702,7 +726,7 @@ function createPatchedFetch() {
 			if (err instanceof BodyTooLargeForCacheKeyError || err instanceof SkipCacheKeyGenerationError) {
 				fetchInit = stripNextFromInit(fetchInit, cacheDirective);
 				recordDynamicFetchObservation(input);
-				return dedupeFetch(input, fetchInit);
+				return recordFetchOutcome(await dedupeFetch(input, fetchInit), "miss", cacheReason);
 			}
 			throw err;
 		}
@@ -726,13 +750,13 @@ function createPatchedFetch() {
 			if (cached?.value && cached.value.kind === "FETCH" && cached.cacheState !== "stale") {
 				await lowerFetchCacheRevalidateIfNeeded(handler, cacheKey, cached.value, tags, revalidateSeconds);
 				const cachedData = cached.value.data;
-				return buildCachedFetchResponse(cachedData, input);
+				return recordFetchOutcome(buildCachedFetchResponse(cachedData, input), "hit", cacheReason);
 			}
 			if (cached?.value && cached.value.kind === "FETCH" && cached.cacheState === "stale") {
 				if (shouldRefreshStaleFetchInForeground()) {
 					const freshResponse = await dedupeFetch(input, fetchInit);
 					await writeFetchCacheResponse(handler, cacheKey, freshResponse, tags, revalidateSeconds);
-					return freshResponse;
+					return recordFetchOutcome(freshResponse, "miss", cacheReason);
 				}
 				const staleData = cached.value.data;
 				if (!pendingRefetches.has(cacheKey)) {
@@ -751,7 +775,7 @@ function createPatchedFetch() {
 					}, DEDUP_TIMEOUT_MS);
 					getRequestExecutionContext()?.waitUntil(refetchPromise);
 				}
-				return buildCachedFetchResponse(staleData, input);
+				return recordFetchOutcome(buildCachedFetchResponse(staleData, input), "hit", cacheReason);
 			}
 		} catch (cacheErr) {
 			console.error("[vinext] fetch cache read error:", cacheErr);
@@ -765,8 +789,12 @@ function createPatchedFetch() {
 		}).catch((err) => {
 			console.error("[vinext] fetch cache write error:", err);
 		});
-		return response;
+		return recordFetchOutcome(response, "miss", cacheReason);
 	};
+	return ((input, init) => {
+		if ((init?.next)?.internal === true) return originalFetch(input, init);
+		return traceAppFetch(input, init, (span) => patchedFetch(input, init, span));
+	});
 }
 /**
 * Strip the `next` property from RequestInit before passing to real fetch.
@@ -819,6 +847,7 @@ async function runWithFetchCache(fn) {
 		uCtx.refreshStaleFetchesInForeground = false;
 		uCtx.isFetchDedupeActive = true;
 		uCtx.currentFetchDedupeEntries = /* @__PURE__ */ new Map();
+		uCtx.nextFetchId = 1;
 	}, fn);
 	return _als.run({
 		cacheableFetchUrls: /* @__PURE__ */ new Set(),
@@ -830,7 +859,8 @@ async function runWithFetchCache(fn) {
 		dynamicFetchUrls: /* @__PURE__ */ new Set(),
 		refreshStaleFetchesInForeground: false,
 		isFetchDedupeActive: true,
-		currentFetchDedupeEntries: /* @__PURE__ */ new Map()
+		currentFetchDedupeEntries: /* @__PURE__ */ new Map(),
+		nextFetchId: 1
 	}, fn);
 }
 function runWithFetchDedupe(fn) {

package/dist/shims/font-google-base.d.ts

@@ -1,7 +1,7 @@
 import { FontStyle } from "./font-utils.js";
 //#region src/shims/font-google-base.d.ts
 type CssVariable = `--${string}`;
-type FontOptions<T extends CssVariable | undefined = CssVariable | undefined> = {
+export type FontOptions<T extends CssVariable | undefined = CssVariable | undefined> = {
   weight?: string | string[];
   style?: string | string[];
   subsets?: string[];
@@ -12,7 +12,7 @@ type FontOptions<T extends CssVariable | undefined = CssVariable | undefined> =
   variable?: T;
   axes?: string[];
 };
-type FontResult = {
+export type FontResult = {
   className: string;
   style: FontStyle;
   variable?: string;
@@ -54,25 +54,25 @@ type FontLoaderOptions<T extends CssVariable | undefined = CssVariable | undefin
  * given, which makes Google return the default static face (200) instead
  * of the broken `:wght@100..900` URL that issue #885 reports.
  */
-declare function buildGoogleFontsUrl(family: string, options: FontOptions): string;
+export declare function buildGoogleFontsUrl(family: string, options: FontOptions): string;
 /**
  * Get collected SSR font class styles (used by the renderer).
  * Note: We don't clear the arrays because fonts are loaded at module import
  * time and need to persist across all requests in the Workers environment.
  */
-declare function getSSRFontStyles(): string[];
+export declare function getSSRFontStyles(): string[];
 /**
  * Get collected SSR font URLs (used by the renderer).
  * Note: We don't clear the arrays because fonts are loaded at module import
  * time and need to persist across all requests in the Workers environment.
  */
-declare function getSSRFontLinks(): string[];
+export declare function getSSRFontLinks(): string[];
 /**
  * Get collected SSR font preload data (used by the renderer).
  * Returns an array of { href, type } objects for emitting
  * <link rel="preload" as="font" ...> tags.
  */
-declare function getSSRFontPreloads(): Array<{
+export declare function getSSRFontPreloads(): Array<{
   href: string;
   type: string;
 }>;
@@ -82,8 +82,8 @@ type NextFont = Omit<FontResult, "variable"> & {
 type NextFontWithVariable = Omit<NextFont, "variable"> & {
   variable: string;
 };
-type FontLoader = <T extends CssVariable | undefined = undefined>(options?: FontLoaderOptions<T>) => T extends undefined ? NextFont : NextFontWithVariable;
-declare function createFontLoader(family: string): FontLoader;
+export type FontLoader = <T extends CssVariable | undefined = undefined>(options?: FontLoaderOptions<T>) => T extends undefined ? NextFont : NextFontWithVariable;
+export declare function createFontLoader(family: string): FontLoader;
 declare const googleFonts: Record<string, FontLoader>;
 //#endregion
-export { FontLoader, FontOptions, FontResult, buildGoogleFontsUrl, createFontLoader, googleFonts as default, getSSRFontLinks, getSSRFontPreloads, getSSRFontStyles };
+export { googleFonts as default };

package/dist/shims/font-google-base.js

@@ -117,8 +117,9 @@ function buildGoogleFontsUrl(family, options) {
 	const hasNormal = styles.includes("normal");
 	const ital = hasItalic ? [...hasNormal ? ["0"] : [], "1"] : void 0;
 	const normalizedWeights = weights.length === 1 && weights[0] === "variable" ? [] : weights;
+	const wght = normalizedWeights.length > 0 ? normalizedWeights : ital ? ["400"] : void 0;
 	return buildGoogleFontsUrl$1(family, {
-		wght: normalizedWeights.length > 0 ? normalizedWeights : ital ? ["400"] : void 0,
+		wght,
 		ital
 	}, options.display ?? "swap");
 }