vinext 1.4.3 → 1.4.5

package/dist/server/workers-tracing.js

@@ -1,4 +1,4 @@
-//#region src/server/workers-tracing.ts
+// src/server/workers-tracing.ts
 function readExceptionField(error, key) {
 	try {
 		return Reflect.get(error, key);
@@ -63,5 +63,4 @@ function createWorkersTracingIntegration(tracing) {
 		}
 	};
 }
-//#endregion
 export { createWorkersTracingIntegration };

package/dist/shims/amp.d.ts

@@ -1,4 +1,3 @@
-//#region src/shims/amp.d.ts
 /**
  * next/amp shim
  *
@@ -14,5 +13,4 @@ export declare function useAmp(): boolean;
  * Check if AMP is enabled for the current page.
  * Always returns false.
  */
-export declare function isInAmpMode(): boolean;
-//#endregion
+export declare function isInAmpMode(): boolean;

package/dist/shims/amp.js

@@ -1,4 +1,4 @@
-//#region src/shims/amp.ts
+// src/shims/amp.ts
 /**
 * next/amp shim
 *
@@ -19,5 +19,4 @@ function useAmp() {
 function isInAmpMode() {
 	return false;
 }
-//#endregion
 export { isInAmpMode, useAmp };

package/dist/shims/app-router-navigation.d.ts

@@ -0,0 +1,303 @@
+import { RouterHistoryWriteLanding } from "./navigation.js";
+import { AppRoutePrefetchPolicy } from "./internal/app-route-prefetch-policy.js";
+import { NavigationRuntimeVisibleCommitMode } from "../client/navigation-runtime.js";
+import "../server/app-elements.js";
+import { AppElements } from "../server/app-elements-wire.js";
+import { AppRscRenderMode } from "../server/app-rsc-render-mode.js";
+import { AppRouterInstance } from "./internal/app-router-context.js";
+import { AppRouterScrollIntent } from "./app-router-scroll-state.js";
+/** Load rewrite-aware hybrid route ownership before navigation becomes interactive. */
+export declare function preloadHybridClientRouteOwner(): Promise<void>;
+export declare function resolveLoadedHybridClientRewriteHref(href: string, basePath: string): string | null;
+/** Maximum buffered bytes in the RSC prefetch cache. Mirrors Next.js' 50 MB LRU. */
+export declare const MAX_PREFETCH_CACHE_SIZE: number;
+export declare const DYNAMIC_NAVIGATION_CACHE_TTL: number;
+export declare const PREFETCH_CACHE_TTL: number;
+/**
+ * The render's `cacheLife` claim about client reuse. The wire treats the two
+ * variants as mutually exclusive — a response carries either the resolved
+ * bound (`NEXT_ROUTER_STALE_TIME_HEADER`) or the pending marker
+ * (`VINEXT_STALE_TIME_PENDING_HEADER`), never both — so the cached form
+ * encodes that rather than trusting every producer to keep them apart.
+ */
+export type ServerStaleTime =
+/** Cacheable render streamed before its `cacheLife` resolved; reuse is bounded at the 30s floor. */
+{
+  kind: "pending";
+} |
+/** Resolved reuse bound, min-combined with the config-derived `dynamicStaleTimeSeconds`. */
+{
+  kind: "resolved";
+  seconds: number;
+};
+/** A buffered RSC response stored as an ArrayBuffer for replay. */
+export type CachedRscResponse = {
+  compatibilityIdHeader?: string | null;
+  buffer: ArrayBuffer;
+  /** Dynamic bound observed after the RSC stream completed. */
+  completedDynamicStaleTimeSeconds?: number;
+  contentType: string;
+  dynamicStaleTimeSeconds?: number;
+  expiresAt?: number;
+  mountedSlotsHeader?: string | null;
+  paramsHeader: string | null;
+  preparedElements?: AppElements;
+  /**
+   * When the payload arrived from the server. A navigation that commits a
+   * prefetched payload keeps the prefetch's time, so a later full prefetch
+   * judges the data by its age, not by the navigation that reused it.
+   */
+  receivedAt?: number;
+  /**
+   * Streamed `redirect()` side-channel headers. A replayed snapshot must keep
+   * them so the navigation follows the redirect instead of decoding the
+   * redirect payload as a page.
+   */
+  redirectHeader?: string;
+  redirectTypeHeader?: string;
+  renderedPathAndSearch: string | null;
+  serverStaleTime?: ServerStaleTime;
+  url: string;
+};
+export type PrefetchOptions = {
+  kind?: unknown;
+  onInvalidate?: () => void;
+};
+export type PrefetchCacheKind = "loading-shell" | "navigation" | "route-tree";
+export type PrefetchCacheEntry = {
+  cacheForNavigation?: boolean;
+  /**
+   * Set while a full prefetch would be kept as learning-only if its page
+   * renders dynamically. A hover upgrade turns it into a full prefetch.
+   */
+  dynamicStaleTime?: "learning-only" | "full-prefetch";
+  expiresAt?: number;
+  fallbackTtlMs?: number;
+  invalidationTimer?: ReturnType<typeof setTimeout>;
+  mountedSlotsHeader?: string | null;
+  onInvalidateCallbacks?: Set<() => void>;
+  optimisticRouteShell?: boolean;
+  outcome: "pending" | "cache-seeded";
+  snapshot?: CachedRscResponse;
+  cacheKeys?: Set<string>;
+  /** The queue-scheduled request, so a consuming navigation can promote it. */
+  fetchPromise?: Promise<Response>;
+  pending?: Promise<void>;
+  preparedElements?: AppElements;
+  prefetchKind?: PrefetchCacheKind;
+  reuseAfterHistoryRestore?: boolean;
+  searchAgnosticShell?: boolean;
+  size?: number;
+  timestamp: number;
+};
+export declare function getCurrentInterceptionContext(): string | null;
+export declare function getPrefetchInterceptionContext(targetHref: string, currentPathname?: string): string | null;
+export declare function getCurrentNextUrl(): string;
+export declare function createAppPrefetchRequestHeaders(options: {
+  fetchPriority: "auto" | "high" | "low";
+  interceptionContext?: string | null;
+  mountedSlotsHeader?: string | null;
+  prefetchKind?: "auto" | "full";
+  renderMode?: AppRscRenderMode;
+}): Headers;
+/** Get or create the shared in-memory RSC prefetch cache on window. */
+export declare function getPrefetchCache(): Map<string, PrefetchCacheEntry>;
+/**
+ * Read an exact prefetch entry without allowing a settled stale value to
+ * steer a later request. Timers are an eviction optimization, not a freshness
+ * guarantee: background throttling can leave an expired route-tree entry in
+ * the Map until the next foreground read.
+ */
+export declare function getFreshPrefetchCacheEntry(cacheKey: string): PrefetchCacheEntry | undefined;
+/**
+ * Get or create the shared set of already-prefetched RSC URLs on window.
+ * Keyed by interception-aware cache key so distinct source routes do not alias.
+ */
+export declare function getPrefetchedUrls(): Set<string>;
+export declare function resolveCachedRscResponseTtlMs(cached: Pick<CachedRscResponse, "dynamicStaleTimeSeconds" | "serverStaleTime">, fallbackTtlMs: number): number;
+export declare function resolveCachedRscResponseExpiresAt(timestamp: number, cached: Pick<CachedRscResponse, "dynamicStaleTimeSeconds" | "expiresAt" | "serverStaleTime">, fallbackTtlMs: number): number;
+export declare function resolvePrefetchCacheEntryMountedSlotsHeader(entry: PrefetchCacheEntry): string | null;
+export declare function hasPrefetchCacheEntryForNavigation(rscUrl: string, interceptionContext?: string | null, mountedSlotsHeader?: string | null, options?: {
+  additionalRscUrls?: readonly string[];
+  notifyInvalidation?: boolean;
+  onInvalidate?: () => void;
+  /** Called with the matched entry, and the key it was found under, when it is reused. */
+  onReuse?: (entry: PrefetchCacheEntry, cacheKey: string) => void;
+  /** Whether an in-flight entry counts as reusable. Defaults to true. */
+  reusePending?: boolean;
+}): boolean;
+/**
+ * Return whether the exact learning-only Link prefetch is still usable.
+ * Pending entries dedupe concurrent Links; settled entries only suppress a
+ * remount while their response-derived freshness window remains active.
+ */
+export declare function hasFreshLearningOnlyPrefetchCacheEntry(rscUrl: string, interceptionContext?: string | null): boolean;
+export declare function hasSearchAgnosticPrefetchShellForRoute(rscUrl: string, interceptionContext?: string | null, mountedSlotsHeader?: string | null): boolean;
+export declare function discardLearningOnlyPrefetchCacheEntry(rscUrl: string, interceptionContext?: string | null, mountedSlotsHeader?: string | null): boolean;
+/**
+ * Make a prefetch reusable by a navigation, as an `unstable_dynamicOnHover`
+ * hover does. A pending one that would be kept as learning-only becomes a full
+ * prefetch and takes the full-prefetch lifetime. One already kept as
+ * learning-only because its page rendered dynamically is left for the full
+ * prefetch to replace: Next.js refetches it with `FetchStrategy.Full`, so the
+ * page reflects the cookies and headers at hover time.
+ */
+export declare function promotePrefetchCacheEntryForNavigation(cacheKey: string, entry: PrefetchCacheEntry): void;
+export type InvalidatePrefetchCacheOptions = {
+  /** Prefetch the visible links again right away. Defaults to true. */
+  pingVisibleLinks?: boolean;
+};
+export declare function invalidatePrefetchCache(options?: InvalidatePrefetchCacheOptions): void;
+/**
+ * Evict the prefetch entries that may hold dynamic data, for a Server Action
+ * that called `refresh()`. Like Next.js's dynamic-only revalidation, which
+ * evicts its BFCache but keeps its prefetch cache, this keeps route trees,
+ * static prefetches and full prefetches. It drops navigation responses, and
+ * automatic prefetches whose page rendered dynamically or hasn't finished
+ * rendering, including those only kept to learn a route: Next.js's automatic
+ * prefetches never hold dynamic data.
+ */
+export declare function invalidateDynamicPrefetchCache(): void;
+/**
+ * Notify the prefetches that stood in for a visited response (see
+ * `hasNavigationFreshVisitedResponse`), as the visited responses are cleared.
+ */
+export declare function invalidateVisitedResponsePrefetches(): void;
+/**
+ * Prevent completed navigation responses from becoming authoritative again
+ * after restoring a history snapshot. Explicit Link/router prefetches remain
+ * consumable. Responses with a positive cache lifetime and interception
+ * responses retain the cache reuse licensed by Next's segment cache.
+ */
+export declare function disableNavigationResponsePrefetchCacheReuse(): void;
+export declare function seedPrefetchResponseSnapshot(rscUrl: string, snapshot: CachedRscResponse, interceptionContext?: string | null, mountedSlotsHeader?: string | null, fallbackTtlMs?: number, reuseAfterHistoryRestore?: boolean, expiresAt?: number): void;
+/**
+ * Fulfill a full prefetch from the visited response of an earlier navigation,
+ * as Next.js does from its BFCache, instead of issuing a request. The data is
+ * fresh for the static stale time from the navigation, not the dynamic one
+ * (`attemptToFulfillDynamicSegmentFromBFCache`).
+ */
+export declare function seedFullPrefetchFromVisitedResponse(rscUrl: string, interceptionContext: string | null, mountedSlotsHeader: string | null, additionalRscUrls?: readonly string[], onInvalidate?: () => void): boolean;
+/**
+ * Whether a navigation to the URL would reuse the response of an earlier one,
+ * so a prefetch has nothing to fetch. Like Next.js, whose navigation keeps the
+ * route and its segments for `staleTimes.dynamic`. `onInvalidate` fires when
+ * that reuse ends.
+ */
+export declare function hasNavigationFreshVisitedResponse(rscUrl: string, interceptionContext: string | null, mountedSlotsHeader: string | null, additionalRscUrls?: readonly string[], onInvalidate?: () => void): boolean;
+export declare function deletePrefetchResponseSnapshot(rscUrl: string, snapshot: CachedRscResponse, interceptionContext?: string | null): void;
+export declare function createCachedRscResponseSnapshot(response: Response, buffer: ArrayBuffer, responseUrl?: string | null): CachedRscResponse;
+/** Decode an `X-Vinext-Rendered-Path-And-Search` header value. */
+export declare function parseRenderedPathAndSearchHeader(value: string | null): string | null;
+/**
+ * Snapshot an RSC response to an ArrayBuffer for caching and replay.
+ * Consumes the response body and stores it with content-type and URL metadata.
+ */
+export declare function snapshotRscResponse(response: Response): Promise<CachedRscResponse>;
+/**
+ * Reconstruct a Response from a cached RSC snapshot.
+ * Creates a new Response with the original ArrayBuffer so createFromFetch
+ * can consume the stream from scratch.
+ *
+ * NOTE: The reconstructed Response always has `url === ""` — the Response
+ * constructor does not accept a `url` option, and `response.url` is read-only
+ * set by the fetch infrastructure. Callers that need the original URL should
+ * read it from `cached.url` directly rather than from the restored Response.
+ *
+ * @param copy - When true (default), copies the ArrayBuffer so the cached
+ *   snapshot remains replayable (needed for the visited-response cache).
+ *   Pass false for single-consumption paths (e.g. prefetch cache entries
+ *   that are deleted after consumption) to avoid the extra allocation.
+ */
+export declare function restoreRscResponse(cached: CachedRscResponse, copy?: boolean): Response;
+/**
+ * `prefetchRscResponse`'s `prepareSnapshot` for navigation-reusable entries:
+ * decode the cached payload through the App Router runtime so a later
+ * navigation can commit it without re-parsing. Shared by `<Link>` and
+ * `router.prefetch()`.
+ */
+export declare function prepareNavigationPrefetchSnapshot(snapshot: CachedRscResponse): Promise<AppElements>;
+/**
+ * Gate a navigation-reusable prefetch behind the route-tree request shared by
+ * `<Link>` and `router.prefetch()`. Callers retain control of fetch scheduling
+ * and request-only options while freshness, deduplication, and alias reuse stay
+ * identical across both entry points.
+ */
+export declare function fetchRouteTreeGatedPrefetch(options: {
+  fetchFullRscPayload: () => Promise<Response>;
+  fetchRouteTree: (rscUrl: string, headers: Headers) => Promise<Response>;
+  fullHref: string;
+  headers: Headers;
+  interceptionContext: string | null;
+  mountedSlotsHeader: string | null;
+}): Promise<Response>;
+/**
+ * Prefetch an RSC response and snapshot it for later consumption.
+ * Stores the in-flight promise so immediate clicks can await it instead
+ * of firing a duplicate fetch.
+ * Enforces a maximum cache size to prevent unbounded memory growth on
+ * link-heavy pages.
+ */
+export declare function prefetchRscResponse(rscUrl: string, fetchPromise: Promise<Response>, interceptionContext?: string | null, mountedSlotsHeader?: string | null, options?: PrefetchOptions, behavior?: {
+  cacheForNavigation?: boolean;
+  dynamicStaleTime?: AppRoutePrefetchPolicy["dynamicStaleTime"];
+  fallbackTtlMs?: number;
+  optimisticRouteShell?: boolean;
+  prefetchKind?: PrefetchCacheKind;
+  prepareSnapshot?: (snapshot: CachedRscResponse) => Promise<AppElements>;
+  searchAgnosticShell?: boolean;
+}): void;
+export declare function peekPrefetchResponseForNavigation(rscUrl: string, interceptionContext?: string | null, mountedSlotsHeader?: string | null, options?: {
+  additionalRscUrls?: readonly string[];
+}): CachedRscResponse | null;
+/**
+ * Consume a prefetched response for a given rscUrl.
+ * Only returns settled (non-pending) snapshots synchronously.
+ * Returns null if the entry is still in flight or doesn't exist.
+ */
+export declare function consumePrefetchResponse(rscUrl: string, interceptionContext?: string | null, mountedSlotsHeader?: string | null, options?: {
+  additionalRscUrls?: readonly string[];
+}): CachedRscResponse | null;
+/**
+ * Consume a prefetched response for navigation. Unlike the synchronous cache
+ * read above, this waits for an already-started prefetch snapshot before
+ * deciding whether to fetch again. That preserves the ownership invariant set
+ * up by prefetchRscResponse(): a pending cache entry means this URL already has
+ * one in-flight network request that navigation should share.
+ */
+type ConsumePrefetchResponseForNavigationOptions = {
+  additionalRscUrls?: readonly string[];
+  shouldConsume?: () => boolean;
+};
+export declare function consumePrefetchResponseForNavigation(rscUrl: string, interceptionContext?: string | null, mountedSlotsHeader?: string | null, options?: ConsumePrefetchResponseForNavigationOptions): Promise<CachedRscResponse | null>;
+export declare function setMountedSlotsHeader(header: string | null): void;
+export declare function getMountedSlotsHeader(): string | null;
+export declare function pushHistoryStateWithoutNotify(data: unknown, unused: string, url?: string | URL | null, land?: RouterHistoryWriteLanding): void;
+export declare function replaceHistoryStateWithoutNotify(data: unknown, unused: string, url?: string | URL | null, land?: RouterHistoryWriteLanding): void;
+/**
+ * Save the current scroll position into the current history state.
+ * Called before every navigation to enable scroll restoration on back/forward.
+ *
+ * Uses replaceHistoryStateWithoutNotify to avoid triggering the patched
+ * history.replaceState interception (which would cause spurious re-renders).
+ */
+export declare function saveScrollPosition(): void;
+export declare function applyAppRouterScrollFallback(intent: AppRouterScrollIntent): void;
+/**
+ * Navigate to a URL, handling external URLs, hash-only changes, and RSC navigation.
+ */
+export declare function navigateClientSide(href: string, mode: "push" | "replace", scroll: boolean, programmaticTransition?: boolean, visibleCommitMode?: NavigationRuntimeVisibleCommitMode): Promise<void>;
+/**
+ * Called by the App Router browser entry for each RSC navigation it runs.
+ * Returns a release callback for the navigation's settlement.
+ */
+export declare function trackAppRouterNavigationInFlight(): () => void;
+/**
+ * Public App Router instance, exposed for the browser entry so it can wire
+ * `window.next.router` to the same singleton returned from `useRouter()`.
+ *
+ * Mirrors `publicAppRouterInstance` from Next.js's
+ * `packages/next/src/client/components/app-router-instance.ts` (line 392).
+ */
+export declare const appRouterInstance: AppRouterInstance;
+export {};