vinext 1.4.4 → 1.4.5

package/dist/shims/navigation-context-state.js

@@ -1,5 +1,5 @@
 import * as React$1 from "react";
-//#region src/shims/navigation-context-state.ts
+// src/shims/navigation-context-state.ts
 const LAYOUT_SEGMENT_CONTEXT_KEY = Symbol.for("vinext.layoutSegmentContext");
 const SERVER_INSERTED_HTML_CONTEXT_KEY = Symbol.for("vinext.serverInsertedHTMLContext");
 const BFCACHE_ID_MAP_CONTEXT_KEY = Symbol.for("vinext.bfcacheIdMapContext");
@@ -112,5 +112,4 @@ function renderServerInsertedHTML() {
 function clearServerInsertedHTML() {
 	clearInsertedHTMLCallbacks();
 }
-//#endregion
 export { GLOBAL_ACCESSORS_KEY, ServerInsertedHTMLContext, _registerStateAccessors, clearClientHydrationContext, clearServerInsertedHTML, flushServerInsertedHTML, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getLayoutSegmentContext, getNavigationContext, registerServerInsertedHTMLCallback, renderServerInsertedHTML, setNavigationContext };

package/dist/shims/navigation-errors.d.ts

@@ -1,4 +1,3 @@
-//#region src/shims/navigation-errors.d.ts
 /**
  * Server-safe navigation control-flow errors and predicates.
  *
@@ -58,5 +57,4 @@ export declare function isDynamicServerError(error: unknown): error is DynamicSe
  * them. This covers the categories vinext can currently produce.
  */
 export declare function unstable_rethrow(error: unknown): void;
-//#endregion
 export {};

package/dist/shims/navigation-errors.js

@@ -1,5 +1,5 @@
 import { parseRedirectDigest } from "../utils/redirect-digest.js";
-//#region src/shims/navigation-errors.ts
+// src/shims/navigation-errors.ts
 /**
 * Server-safe navigation control-flow errors and predicates.
 *
@@ -112,5 +112,4 @@ function unstable_rethrow(error) {
 	if (isNextRouterError(error) || isBailoutToCSRError(error) || isDynamicServerError(error)) throw error;
 	if (error instanceof Error && "cause" in error) unstable_rethrow(error.cause);
 }
-//#endregion
 export { BailoutToCSRError, DynamicServerError, HTTP_ERROR_FALLBACK_ERROR_CODE, RedirectType, decodeRedirectError, forbidden, getAccessFallbackHTTPStatus, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, isThrownNavigationError, notFound, permanentRedirect, redirect, unauthorized, unstable_rethrow };

package/dist/shims/navigation-state.d.ts

@@ -1,6 +1,5 @@
 import { NavigationContext } from "./navigation-context-state.js";
 import "./navigation-server.js";
-//#region src/shims/navigation-state.d.ts
 export type NavigationState = {
   serverContext: NavigationContext | null;
   serverInsertedHTMLCallbacks: Array<() => unknown>;
@@ -21,5 +20,4 @@ export declare function runWithNavigationContext<T>(fn: () => T | Promise<T>): T
  * streamed render cannot accumulate into the cache-fill render.
  */
 export declare function runWithServerInsertedHTMLState<T>(fn: () => Promise<T>): Promise<T>;
-export declare function runWithServerInsertedHTMLState<T>(fn: () => T | Promise<T>): T | Promise<T>;
-//#endregion
+export declare function runWithServerInsertedHTMLState<T>(fn: () => T | Promise<T>): T | Promise<T>;

package/dist/shims/navigation-state.js

@@ -1,8 +1,8 @@
 import { getOrCreateAls } from "./internal/als-registry.js";
-import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
-import { GLOBAL_ACCESSORS_KEY, _registerStateAccessors } from "./navigation-context-state.js";
 import "./navigation-server.js";
-//#region src/shims/navigation-state.ts
+import { GLOBAL_ACCESSORS_KEY, _registerStateAccessors } from "./navigation-context-state.js";
+import { getRequestContext, isInsideUnifiedScope, runWithUnifiedStateMutation } from "./unified-request-context.js";
+// src/shims/navigation-state.ts
 /**
 * Server-only navigation state backed by AsyncLocalStorage.
 *
@@ -62,5 +62,4 @@ const _accessors = {
 };
 _registerStateAccessors(_accessors);
 globalThis[GLOBAL_ACCESSORS_KEY] = _accessors;
-//#endregion
 export { runWithNavigationContext, runWithServerInsertedHTMLState };

package/dist/shims/navigation.d.ts

@@ -1,302 +1,15 @@
-import { AppRouterScrollIntent } from "./app-router-scroll-state.js";
-import { AppRouterInstance, NavigateOptions, PrefetchOptions as PrefetchOptions$1 } from "./internal/app-router-context.js";
-import { AppRoutePrefetchPolicy } from "./internal/app-route-prefetch-policy.js";
-import { AppElements } from "../server/app-elements-wire.js";
-import "../server/app-elements.js";
+import { NavigateOptions, PrefetchOptions } from "./internal/app-router-context.js";
 import { ReadonlyURLSearchParams } from "./readonly-url-search-params.js";
-import { AppRscRenderMode } from "../server/app-rsc-render-mode.js";
 import { GLOBAL_ACCESSORS_KEY, NavigationContext, NavigationStateAccessors, SegmentMap, ServerInsertedHTMLContext, _registerStateAccessors, clearServerInsertedHTML, flushServerInsertedHTML, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getLayoutSegmentContext, getNavigationContext, renderServerInsertedHTML, setNavigationContext } from "./navigation-context-state.js";
 import { BailoutToCSRError, DynamicServerError, HTTP_ERROR_FALLBACK_ERROR_CODE, RedirectType, decodeRedirectError, forbidden, getAccessFallbackHTTPStatus, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, notFound, permanentRedirect, redirect, unauthorized, unstable_rethrow } from "./navigation-errors.js";
 import { UnrecognizedActionError, unstable_isUnrecognizedActionError } from "./unrecognized-action-error.js";
-import { NavigationRuntimeVisibleCommitMode } from "../client/navigation-runtime.js";
 import * as React$1 from "react";
 import { Params } from "@vinext/types/next/upstream/dist/server/request/params";
-//#region src/shims/navigation.d.ts
-/** 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;
 /** basePath from next.config.js, injected by the plugin at build time */
 export declare const __basePath: string;
-/** 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;
-/**
- * Store a prefetched RSC response in the cache by snapshotting it to an
- * ArrayBuffer.  The snapshot completes asynchronously; during that window
- * the entry is marked `pending` so consumePrefetchResponse() will skip it
- * (the caller falls back to a fresh fetch, which is acceptable).
- *
- * Prefer prefetchRscResponse() for new call-sites — it handles the full
- * prefetch lifecycle including dedup and explicit slot context.
- * storePrefetchResponse() is kept for backward compatibility and test
- * helpers. It is slot-unaware: the snapshot's mountedSlotsHeader comes
- * from the response headers, not the caller, so consumePrefetchResponse
- * may reject the entry if the caller's slot context differs.
- *
- * NB: Caller is responsible for managing getPrefetchedUrls() — this
- * function only stores the response in the prefetch cache.
- */
-export declare function storePrefetchResponse(rscUrl: string, response: Response, interceptionContext?: string | null, options?: PrefetchOptions): 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>;
 type NavigationListener = () => void;
-type ClientNavigationState = {
+/** @internal Shared with the App Router navigation runtime. */
+export type ClientNavigationState = {
   listeners: Set<NavigationListener>;
   cachedSearch: string;
   cachedReadonlySearchParams: ReadonlyURLSearchParams;
@@ -316,7 +29,8 @@ type ClientNavigationState = {
   suppressUrlNotifyCount: number;
   navigationSnapshotActiveCount: number;
 };
-type RouterHistoryWrite = {
+/** @internal */
+export type RouterHistoryWrite = {
   method: "pushState" | "replaceState";
   data: unknown;
   url: string | URL;
@@ -340,8 +54,6 @@ export type RouterHistoryWriteLanding = (data: unknown) => {
 type CommitClientNavigationStateOptions = {
   releaseSnapshot?: boolean;
 };
-export declare function setMountedSlotsHeader(header: string | null): void;
-export declare function getMountedSlotsHeader(): string | null;
 export declare function getClientNavigationState(): ClientNavigationState | null;
 /**
  * Mark a navigation snapshot as active. Called before startTransition
@@ -410,34 +122,6 @@ export declare function useParams<T extends Params = Params>(): T | null;
  * must opt in explicitly if they also own an activated render snapshot.
  */
 export declare function commitClientNavigationState(navId?: number, options?: CommitClientNavigationStateOptions): void;
-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;
 /**
  * App Router's useRouter — returns push/replace/back/forward/refresh.
  * Different from Pages Router's useRouter (next/router).
@@ -451,7 +135,7 @@ export declare function useRouter(): {
   refresh(): void;
   push(href: string, options?: NavigateOptions): void;
   replace(href: string, options?: NavigateOptions): void;
-  prefetch(href: string, options?: PrefetchOptions$1): void;
+  prefetch(href: string, options?: PrefetchOptions): void;
   experimental_gesturePush?(href: string, options?: NavigateOptions): void;
   bfcacheId: string;
 };
@@ -492,5 +176,4 @@ export declare function useSelectedLayoutSegments(parallelRoutesKey?: string): s
  *   });
  */
 export declare function useServerInsertedHTML(callback: () => unknown): void;
-//#endregion
 export { BailoutToCSRError, DynamicServerError, GLOBAL_ACCESSORS_KEY, HTTP_ERROR_FALLBACK_ERROR_CODE, type NavigationContext, type NavigationStateAccessors, ReadonlyURLSearchParams, RedirectType, type SegmentMap, ServerInsertedHTMLContext, UnrecognizedActionError, _registerStateAccessors, clearServerInsertedHTML, decodeRedirectError, flushServerInsertedHTML, forbidden, getAccessFallbackHTTPStatus, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getLayoutSegmentContext, getNavigationContext, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, notFound, permanentRedirect, redirect, renderServerInsertedHTML, setNavigationContext, unauthorized, unstable_isUnrecognizedActionError, unstable_rethrow };