vinext 0.1.1 → 0.1.2

package/dist/shims/navigation.d.ts

@@ -1,4 +1,5 @@
-import { NavigateOptions, PrefetchOptions as PrefetchOptions$1 } from "./internal/app-router-context.js";
+import { NavigationRuntimeVisibleCommitMode } from "../client/navigation-runtime.js";
+import { AppRouterInstance, NavigateOptions, PrefetchOptions as PrefetchOptions$1 } from "./internal/app-router-context.js";
 import { ReadonlyURLSearchParams } from "./readonly-url-search-params.js";
 import { UnrecognizedActionError, unstable_isUnrecognizedActionError } from "./unrecognized-action-error.js";
 import * as React$1 from "react";
@@ -205,6 +206,7 @@ type ClientNavigationRenderSnapshot = {
 };
 declare function getClientNavigationRenderContext(): React$1.Context<ClientNavigationRenderSnapshot | null> | null;
 declare function createClientNavigationRenderSnapshot(href: string, params: Record<string, string | string[]>): ClientNavigationRenderSnapshot;
+declare function createSnapshotPathAndSearch(snapshot: ClientNavigationRenderSnapshot): string;
 declare function setClientParams(params: Record<string, string | string[]>): void;
 declare function replaceClientParamsWithoutNotify(params: Record<string, string | string[]>): void;
 /** Get the current client params (for testing referential stability). */
@@ -256,7 +258,7 @@ declare function saveScrollPosition(): void;
 /**
  * Navigate to a URL, handling external URLs, hash-only changes, and RSC navigation.
  */
-declare function navigateClientSide(href: string, mode: "push" | "replace", scroll: boolean, programmaticTransition?: boolean): Promise<void>;
+declare function navigateClientSide(href: string, mode: "push" | "replace", scroll: boolean, programmaticTransition?: boolean, visibleCommitMode?: NavigationRuntimeVisibleCommitMode): Promise<void>;
 /**
  * Public App Router instance, exposed for the browser entry so it can wire
  * `window.next.router` to the same singleton returned from `useRouter()`.
@@ -264,19 +266,7 @@ declare function navigateClientSide(href: string, mode: "push" | "replace", scro
  * Mirrors `publicAppRouterInstance` from Next.js's
  * `packages/next/src/client/components/app-router-instance.ts` (line 392).
  */
-declare const appRouterInstance: {
-  bfcacheId: string;
-  push(href: string, options?: {
-    scroll?: boolean;
-  }): void;
-  replace(href: string, options?: {
-    scroll?: boolean;
-  }): void;
-  back(): void;
-  forward(): void;
-  refresh(): void;
-  prefetch(href: string, options?: PrefetchOptions): void;
-};
+declare const appRouterInstance: AppRouterInstance;
 /**
  * App Router's useRouter — returns push/replace/back/forward/refresh.
  * Different from Pages Router's useRouter (next/router).
@@ -292,6 +282,7 @@ declare function useRouter(): {
   push(href: string, options?: NavigateOptions): void;
   replace(href: string, options?: NavigateOptions): void;
   prefetch(href: string, options?: PrefetchOptions$1): void;
+  experimental_gesturePush?(href: string, options?: NavigateOptions): void;
 };
 /**
  * Returns the active child segment one level below the layout where it's called.
@@ -574,4 +565,4 @@ declare function isDynamicServerError(error: unknown): error is DynamicServerErr
  */
 declare function unstable_rethrow(error: unknown): void;
 //#endregion
-export { BailoutToCSRError, CachedRscResponse, ClientNavigationRenderSnapshot, DynamicServerError, GLOBAL_ACCESSORS_KEY, HTTP_ERROR_FALLBACK_ERROR_CODE, MAX_PREFETCH_CACHE_SIZE, NavigationContext, PREFETCH_CACHE_TTL, PrefetchCacheEntry, PrefetchOptions, ReadonlyURLSearchParams, RedirectType, SegmentMap, ServerInsertedHTMLContext, UnrecognizedActionError, __basePath, _registerStateAccessors, activateNavigationSnapshot, appRouterInstance, clearPendingPathname, clearServerInsertedHTML, commitClientNavigationState, consumePrefetchResponse, consumePrefetchResponseForNavigation, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, decodeRedirectError, flushServerInsertedHTML, forbidden, getAccessFallbackHTTPStatus, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getClientNavigationRenderContext, getClientNavigationState, getClientParams, getCurrentInterceptionContext, getCurrentNextUrl, getLayoutSegmentContext, getMountedSlotsHeader, getNavigationContext, getPrefetchCache, getPrefetchInterceptionContext, getPrefetchedUrls, hasPrefetchCacheEntryForNavigation, invalidatePrefetchCache, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, navigateClientSide, notFound, permanentRedirect, prefetchRscResponse, pushHistoryStateWithoutNotify, redirect, renderServerInsertedHTML, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, resolveCachedRscResponseExpiresAt, resolveCachedRscResponseTtlMs, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, setClientParams, setMountedSlotsHeader, setNavigationContext, setPendingPathname, snapshotRscResponse, storePrefetchResponse, unauthorized, unstable_isUnrecognizedActionError, unstable_rethrow, useParams, usePathname, useRouter, useSearchParams, useSelectedLayoutSegment, useSelectedLayoutSegments, useServerInsertedHTML };
+export { BailoutToCSRError, CachedRscResponse, ClientNavigationRenderSnapshot, DynamicServerError, GLOBAL_ACCESSORS_KEY, HTTP_ERROR_FALLBACK_ERROR_CODE, MAX_PREFETCH_CACHE_SIZE, NavigationContext, PREFETCH_CACHE_TTL, PrefetchCacheEntry, PrefetchOptions, ReadonlyURLSearchParams, RedirectType, SegmentMap, ServerInsertedHTMLContext, UnrecognizedActionError, __basePath, _registerStateAccessors, activateNavigationSnapshot, appRouterInstance, clearPendingPathname, clearServerInsertedHTML, commitClientNavigationState, consumePrefetchResponse, consumePrefetchResponseForNavigation, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, createSnapshotPathAndSearch, decodeRedirectError, flushServerInsertedHTML, forbidden, getAccessFallbackHTTPStatus, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getClientNavigationRenderContext, getClientNavigationState, getClientParams, getCurrentInterceptionContext, getCurrentNextUrl, getLayoutSegmentContext, getMountedSlotsHeader, getNavigationContext, getPrefetchCache, getPrefetchInterceptionContext, getPrefetchedUrls, hasPrefetchCacheEntryForNavigation, invalidatePrefetchCache, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, navigateClientSide, notFound, permanentRedirect, prefetchRscResponse, pushHistoryStateWithoutNotify, redirect, renderServerInsertedHTML, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, resolveCachedRscResponseExpiresAt, resolveCachedRscResponseTtlMs, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, setClientParams, setMountedSlotsHeader, setNavigationContext, setPendingPathname, snapshotRscResponse, storePrefetchResponse, unauthorized, unstable_isUnrecognizedActionError, unstable_rethrow, useParams, usePathname, useRouter, useSearchParams, useSelectedLayoutSegment, useSelectedLayoutSegments, useServerInsertedHTML };

package/dist/shims/navigation.js

@@ -4,7 +4,7 @@ import { assertSafeNavigationUrl } from "./url-safety.js";
 import { AppElementsWire } from "../server/app-elements-wire.js";
 import "../server/app-elements.js";
 import { AppRouterContext } from "./internal/app-router-context.js";
-import { isAbsoluteOrProtocolRelativeUrl, isHashOnlyBrowserUrlChange, toBrowserNavigationHref, toSameOriginAppPath, withBasePath } from "./url-utils.js";
+import { isAbsoluteOrProtocolRelativeUrl, toBrowserNavigationHref, toSameOriginAppPath, withBasePath } from "./url-utils.js";
 import { retryScrollTo, scrollToHashTarget } from "./hash-scroll.js";
 import { getNavigationRuntime, hasAppNavigationRuntime } from "../client/navigation-runtime.js";
 import { notifyAppRouterTransitionStart } from "../client/instrumentation-client-state.js";
@@ -13,6 +13,7 @@ import { resolveManifestNavigationInterceptionContext } from "../server/app-brow
 import { createExternalHistoryStatePreservingMetadata, createHashOnlyHistoryStatePreservingNavigationMetadata } from "../server/app-history-state.js";
 import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, createRscRequestHeaders, createRscRequestUrl, stripRscCacheBustingSearchParam } from "../server/app-rsc-cache-busting.js";
 import { hasPendingAppRouterPageRedirect } from "../server/app-browser-mpa-navigation.js";
+import { navigationPlanner } from "../server/navigation-planner.js";
 import { ReadonlyURLSearchParams } from "./readonly-url-search-params.js";
 import { beginAppRouterScrollIntent, clearAppRouterScrollIntent, consumeAppRouterScrollIntent } from "./app-router-scroll-state.js";
 import { UnrecognizedActionError, unstable_isUnrecognizedActionError } from "./unrecognized-action-error.js";
@@ -715,6 +716,10 @@ function createClientNavigationRenderSnapshot(href, params) {
 		params
 	};
 }
+function createSnapshotPathAndSearch(snapshot) {
+	const query = snapshot.searchParams.toString();
+	return query === "" ? snapshot.pathname : `${snapshot.pathname}?${query}`;
+}
 let _fallbackClientParams = _EMPTY_PARAMS;
 let _fallbackClientParamsJson = "{}";
 function setClientParams(params) {
@@ -844,14 +849,6 @@ function useParams() {
 function isExternalUrl(href) {
 	return isAbsoluteOrProtocolRelativeUrl(href);
 }
-/**
-* Check if a href is only a hash change relative to the current URL.
-*/
-function isHashOnlyChange(href) {
-	if (typeof window === "undefined") return false;
-	if (href.startsWith("#")) return true;
-	return isHashOnlyBrowserUrlChange(href, window.location.href, __basePath);
-}
 function withSuppressedUrlNotifications(fn) {
 	const state = getClientNavigationState();
 	if (!state) return fn();
@@ -963,7 +960,7 @@ function restoreScrollPosition(state) {
 /**
 * Navigate to a URL, handling external URLs, hash-only changes, and RSC navigation.
 */
-async function navigateClientSide(href, mode, scroll, programmaticTransition = false) {
+async function navigateClientSide(href, mode, scroll, programmaticTransition = false, visibleCommitMode = "transition") {
 	getNavigationRuntime()?.functions.notifyLinkNavigationStart?.();
 	let normalizedHref = href;
 	if (isExternalUrl(href)) {
@@ -985,11 +982,17 @@ async function navigateClientSide(href, mode, scroll, programmaticTransition = f
 	const fullHref = toBrowserNavigationHref(normalizedHref, window.location.href, __basePath);
 	notifyAppRouterTransitionStart(fullHref, mode);
 	if (mode === "push") saveScrollPosition();
-	if (isHashOnlyChange(fullHref)) {
-		const hash = fullHref.includes("#") ? fullHref.slice(fullHref.indexOf("#")) : "";
-		commitHashOnlyHistoryState(fullHref, mode, scroll);
+	const earlyIntent = navigationPlanner.classifyEarlyNavigationIntent({
+		basePath: __basePath,
+		currentHref: window.location.href,
+		mode,
+		scroll,
+		targetHref: fullHref
+	});
+	if (earlyIntent.kind === "sameDocumentScroll") {
+		commitHashOnlyHistoryState(fullHref, earlyIntent.mode, earlyIntent.scroll);
 		commitClientNavigationState();
-		if (scroll) scrollToHashTarget(hash);
+		if (earlyIntent.scroll) scrollToHashTarget(earlyIntent.hash);
 		return;
 	}
 	if (hasPendingAppRouterPageRedirect(typeof document === "undefined" ? void 0 : document)) {
@@ -1009,7 +1012,7 @@ async function navigateClientSide(href, mode, scroll, programmaticTransition = f
 	if (!scroll) clearAppRouterScrollIntent();
 	const appNavigate = getNavigationRuntime()?.functions.navigate;
 	try {
-		if (appNavigate) await appNavigate(fullHref, 0, "navigate", mode, void 0, programmaticTransition, void 0, scrollIntent);
+		if (appNavigate) await appNavigate(fullHref, 0, "navigate", mode, void 0, programmaticTransition, void 0, scrollIntent, visibleCommitMode);
 		else {
 			if (mode === "replace") replaceHistoryStateWithoutNotify(null, "", fullHref);
 			else pushHistoryStateWithoutNotify(null, "", fullHref);
@@ -1137,6 +1140,20 @@ const _appRouter = {
 		});
 	}
 };
+if (process.env.__NEXT_GESTURE_TRANSITION) _appRouter.experimental_gesturePush = (href, options) => {
+	assertSafeNavigationUrl(href);
+	if (isServer) return;
+	if (!getNavigationRuntime()?.functions.navigate) return;
+	let appHref = href;
+	if (isAbsoluteOrProtocolRelativeUrl(href)) {
+		const localPath = toSameOriginAppPath(href, __basePath);
+		if (localPath === null) return;
+		appHref = localPath;
+	}
+	const releaseNavigation = trackScheduledAppRouterNavigation();
+	navigateClientSide(appHref, "push", options?.scroll !== false, false, "synchronous");
+	releaseScheduledAppRouterNavigationAfterCurrentTask(releaseNavigation);
+};
 function formatPublicBfcacheId(value) {
 	if (!value || value === "0") return PUBLIC_INITIAL_BFCACHE_ID;
 	return value;
@@ -1585,4 +1602,4 @@ if (!isServer) {
 	}
 }
 //#endregion
-export { BailoutToCSRError, DynamicServerError, GLOBAL_ACCESSORS_KEY, HTTP_ERROR_FALLBACK_ERROR_CODE, MAX_PREFETCH_CACHE_SIZE, PREFETCH_CACHE_TTL, ReadonlyURLSearchParams, RedirectType, ServerInsertedHTMLContext, UnrecognizedActionError, __basePath, _registerStateAccessors, activateNavigationSnapshot, appRouterInstance, clearPendingPathname, clearServerInsertedHTML, commitClientNavigationState, consumePrefetchResponse, consumePrefetchResponseForNavigation, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, decodeRedirectError, flushServerInsertedHTML, forbidden, getAccessFallbackHTTPStatus, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getClientNavigationRenderContext, getClientNavigationState, getClientParams, getCurrentInterceptionContext, getCurrentNextUrl, getLayoutSegmentContext, getMountedSlotsHeader, getNavigationContext, getPrefetchCache, getPrefetchInterceptionContext, getPrefetchedUrls, hasPrefetchCacheEntryForNavigation, invalidatePrefetchCache, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, navigateClientSide, notFound, permanentRedirect, prefetchRscResponse, pushHistoryStateWithoutNotify, redirect, renderServerInsertedHTML, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, resolveCachedRscResponseExpiresAt, resolveCachedRscResponseTtlMs, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, setClientParams, setMountedSlotsHeader, setNavigationContext, setPendingPathname, snapshotRscResponse, storePrefetchResponse, unauthorized, unstable_isUnrecognizedActionError, unstable_rethrow, useParams, usePathname, useRouter, useSearchParams, useSelectedLayoutSegment, useSelectedLayoutSegments, useServerInsertedHTML };
+export { BailoutToCSRError, DynamicServerError, GLOBAL_ACCESSORS_KEY, HTTP_ERROR_FALLBACK_ERROR_CODE, MAX_PREFETCH_CACHE_SIZE, PREFETCH_CACHE_TTL, ReadonlyURLSearchParams, RedirectType, ServerInsertedHTMLContext, UnrecognizedActionError, __basePath, _registerStateAccessors, activateNavigationSnapshot, appRouterInstance, clearPendingPathname, clearServerInsertedHTML, commitClientNavigationState, consumePrefetchResponse, consumePrefetchResponseForNavigation, createCachedRscResponseSnapshot, createClientNavigationRenderSnapshot, createSnapshotPathAndSearch, decodeRedirectError, flushServerInsertedHTML, forbidden, getAccessFallbackHTTPStatus, getBfcacheIdMapContext, getBfcacheSegmentIdContext, getClientNavigationRenderContext, getClientNavigationState, getClientParams, getCurrentInterceptionContext, getCurrentNextUrl, getLayoutSegmentContext, getMountedSlotsHeader, getNavigationContext, getPrefetchCache, getPrefetchInterceptionContext, getPrefetchedUrls, hasPrefetchCacheEntryForNavigation, invalidatePrefetchCache, isBailoutToCSRError, isDynamicServerError, isHTTPAccessFallbackError, isNextRouterError, isRedirectError, navigateClientSide, notFound, permanentRedirect, prefetchRscResponse, pushHistoryStateWithoutNotify, redirect, renderServerInsertedHTML, replaceClientParamsWithoutNotify, replaceHistoryStateWithoutNotify, resolveCachedRscResponseExpiresAt, resolveCachedRscResponseTtlMs, resolvePrefetchCacheEntryMountedSlotsHeader, restoreRscResponse, saveScrollPosition, setClientParams, setMountedSlotsHeader, setNavigationContext, setPendingPathname, snapshotRscResponse, storePrefetchResponse, unauthorized, unstable_isUnrecognizedActionError, unstable_rethrow, useParams, usePathname, useRouter, useSearchParams, useSelectedLayoutSegment, useSelectedLayoutSegments, useServerInsertedHTML };

package/dist/shims/router.js

@@ -1,5 +1,5 @@
 import { splitPathSegments } from "../routing/utils.js";
-import { stripBasePath } from "../utils/base-path.js";
+import { removeTrailingSlash, stripBasePath } from "../utils/base-path.js";
 import { assertSafeNavigationUrl } from "./url-safety.js";
 import { matchRoutePattern, routePatternParts } from "../routing/route-pattern.js";
 import { isUnknownRecord } from "../utils/record.js";
@@ -1017,6 +1017,14 @@ async function performNavigation(url, as, options, mode, onStateUpdate) {
 		dispatchNavigateEvent();
 		return true;
 	}
+	const appPath = getLocalPathname(resolved);
+	const appPathNorm = appPath !== null ? removeTrailingSlash(appPath) : null;
+	const appPathEntry = appPathNorm !== null ? getPagesRouterComponentsMap()[appPathNorm] : void 0;
+	if (appPathEntry !== void 0 && "__appRouter" in appPathEntry && appPathEntry.__appRouter) {
+		if (mode === "push") window.location.assign(full);
+		else window.location.replace(full);
+		return new Promise(() => {});
+	}
 	if (mode === "push") saveScrollPosition();
 	routerEvents.emit("routeChangeStart", resolved, { shallow });
 	routerEvents.emit("beforeHistoryChange", resolved, { shallow });
@@ -1338,6 +1346,25 @@ const Router = Object.defineProperties(RouterMethods, {
 		}
 	}
 });
+for (const event of [
+	"routeChangeStart",
+	"beforeHistoryChange",
+	"routeChangeComplete",
+	"routeChangeError",
+	"hashChangeStart",
+	"hashChangeComplete"
+]) {
+	const eventField = `on${event.charAt(0).toUpperCase()}${event.substring(1)}`;
+	routerEvents.on(event, (...args) => {
+		const handler = Router[eventField];
+		if (typeof handler === "function") try {
+			handler(...args);
+		} catch (err) {
+			console.error(`Error when running the Router event: ${eventField}`);
+			console.error(err instanceof Error ? `${err.message}\n${err.stack}` : String(err));
+		}
+	});
+}
 if (typeof window !== "undefined") installWindowNext({ router: Router });
 const _PAGES_NAVIGATION_ACCESSOR_KEY = Symbol.for("vinext.navigation.pagesNavigationContextAccessor");
 globalThis[_PAGES_NAVIGATION_ACCESSOR_KEY] = getPagesNavigationContext;

package/dist/shims/script-nonce-context.d.ts

@@ -1,7 +1,7 @@
 import React from "react";
 
 //#region src/shims/script-nonce-context.d.ts
-declare const ScriptNonceContext: React.Context<string | undefined>;
+declare const ScriptNonceContext: React.Context<string | undefined> | null;
 declare function ScriptNonceProvider(props: React.PropsWithChildren<{
   nonce?: string;
 }>): React.ReactElement;

package/dist/shims/script-nonce-context.js

@@ -1,15 +1,23 @@
 import React from "react";
 //#region src/shims/script-nonce-context.tsx
-const ScriptNonceContext = React.createContext(void 0);
+const ScriptNonceContext = typeof React.createContext === "function" ? React.createContext(void 0) : null;
 function ScriptNonceProvider(props) {
+	if (!ScriptNonceContext) return React.createElement(React.Fragment, null, props.children);
 	return React.createElement(ScriptNonceContext.Provider, { value: props.nonce }, props.children);
 }
 function withScriptNonce(element, nonce) {
-	if (!nonce) return element;
+	if (!nonce || !ScriptNonceContext) return element;
 	return React.createElement(ScriptNonceProvider, { nonce }, element);
 }
+function createScriptNonceHook(context) {
+	if (!context || typeof React.useContext !== "function") return function useScriptNonceFromContext() {};
+	return function useScriptNonceFromContext() {
+		return React.useContext(context);
+	};
+}
+const useScriptNonceFromContext = createScriptNonceHook(ScriptNonceContext);
 function useScriptNonce() {
-	return React.useContext(ScriptNonceContext);
+	return useScriptNonceFromContext();
 }
 //#endregion
 export { ScriptNonceContext, ScriptNonceProvider, useScriptNonce, withScriptNonce };

package/dist/shims/server.d.ts

@@ -91,13 +91,29 @@ type NextURLConfig = {
 declare class NextURL {
   /** Internal URL stores the pathname WITHOUT basePath or locale prefix. */
   private _url;
+  /**
+   * The configured basePath (from nextConfig). May differ from the active
+   * `_basePath`: parsing only activates basePath when the URL's pathname
+   * actually carries the configured prefix.
+   */
+  private _configBasePath;
   private _basePath;
   private _trailingSlash;
   private _locale;
   private _defaultLocale;
   private _locales;
   constructor(input: string | URL, base?: string | URL, config?: NextURLConfig);
-  /** Strip basePath prefix from the internal pathname. */
+  /** Strip basePath prefix from the internal pathname.
+   * Mirrors Next.js's getNextPathnameInfo (re-run by NextURL.analyze() on
+   * every parse, including `href` reassignment): basePath is only considered
+   * active when the URL's pathname actually starts with the configured
+   * basePath prefix. If the pathname is outside the basePath, the active
+   * basePath is cleared to "" so that request.nextUrl.basePath reflects the
+   * actual URL rather than the config value; if a later `href` assignment
+   * moves the URL back inside the basePath, it is re-activated from the
+   * configured value. This matches the Next.js behavior tested by
+   * middleware-base-path's "should execute from absolute paths" case.
+   */
   private _stripBasePath;
   /** Extract locale from pathname, stripping it from the internal URL. */
   private _analyzeLocale;

package/dist/shims/server.js

@@ -1,4 +1,4 @@
-import { stripBasePath } from "../utils/base-path.js";
+import { hasBasePath, stripBasePath } from "../utils/base-path.js";
 import { getRequestExecutionContext } from "./request-context.js";
 import { MIDDLEWARE_NEXT_HEADER, MIDDLEWARE_REWRITE_HEADER, MIDDLEWARE_SET_COOKIE_HEADER } from "../server/headers.js";
 import { encodeMiddlewareRequestHeaders } from "../server/middleware-request-headers.js";
@@ -183,6 +183,12 @@ var NextResponse = class NextResponse extends Response {
 var NextURL = class NextURL {
 	/** Internal URL stores the pathname WITHOUT basePath or locale prefix. */
 	_url;
+	/**
+	* The configured basePath (from nextConfig). May differ from the active
+	* `_basePath`: parsing only activates basePath when the URL's pathname
+	* actually carries the configured prefix.
+	*/
+	_configBasePath;
 	_basePath;
 	_trailingSlash;
 	_locale;
@@ -190,7 +196,8 @@ var NextURL = class NextURL {
 	_locales;
 	constructor(input, base, config) {
 		this._url = new URL(input.toString(), base);
-		this._basePath = config?.basePath ?? "";
+		this._configBasePath = config?.basePath ?? "";
+		this._basePath = this._configBasePath;
 		this._trailingSlash = config?.nextConfig?.trailingSlash ?? false;
 		this._stripBasePath();
 		const i18n = config?.nextConfig?.i18n;
@@ -200,10 +207,25 @@ var NextURL = class NextURL {
 			this._analyzeLocale(this._locales);
 		}
 	}
-	/** Strip basePath prefix from the internal pathname. */
+	/** Strip basePath prefix from the internal pathname.
+	* Mirrors Next.js's getNextPathnameInfo (re-run by NextURL.analyze() on
+	* every parse, including `href` reassignment): basePath is only considered
+	* active when the URL's pathname actually starts with the configured
+	* basePath prefix. If the pathname is outside the basePath, the active
+	* basePath is cleared to "" so that request.nextUrl.basePath reflects the
+	* actual URL rather than the config value; if a later `href` assignment
+	* moves the URL back inside the basePath, it is re-activated from the
+	* configured value. This matches the Next.js behavior tested by
+	* middleware-base-path's "should execute from absolute paths" case.
+	*/
 	_stripBasePath() {
-		if (!this._basePath) return;
-		this._url.pathname = stripBasePath(this._url.pathname, this._basePath);
+		if (!this._configBasePath) return;
+		if (!hasBasePath(this._url.pathname, this._configBasePath)) {
+			this._basePath = "";
+			return;
+		}
+		this._basePath = this._configBasePath;
+		this._url.pathname = stripBasePath(this._url.pathname, this._configBasePath);
 	}
 	/** Extract locale from pathname, stripping it from the internal URL. */
 	_analyzeLocale(locales) {
@@ -655,10 +677,13 @@ function after(task) {
 * and sets Cache-Control: no-store on the response.
 */
 async function connection() {
-	const { markDynamicUsage, markRenderRequestApiUsage, throwIfInsideCacheScope } = await import("./headers.js");
+	const { getHeadersContext, markDynamicUsage, markRenderRequestApiUsage, suspendConnectionProbe, throwIfInsideCacheScope } = await import("./headers.js");
+	if (getHeadersContext()?.forceStatic) return;
 	markRenderRequestApiUsage("connection");
 	throwIfInsideCacheScope("connection()");
 	markDynamicUsage();
+	const pendingProbe = suspendConnectionProbe();
+	if (pendingProbe) await pendingProbe;
 }
 /**
 * URLPattern re-export — used in middleware for route matching.

package/dist/shims/slot.js

@@ -23,7 +23,7 @@ const MAX_BFCACHE_SLOT_ENTRIES_WITH_CACHE_COMPONENTS = 3;
 const MAX_BFCACHE_SLOT_ENTRIES_WITHOUT_CACHE_COMPONENTS = 1;
 const BfcacheStateKeyMapContext = React$1.createContext(EMPTY_BFCACHE_STATE_KEYS);
 function isCacheComponentsEnabled() {
-	return process.env.__NEXT_CACHE_COMPONENTS === "true";
+	return String(process.env.__NEXT_CACHE_COMPONENTS) === "true";
 }
 function getBfcacheSlotEntryLimit() {
 	return isCacheComponentsEnabled() ? MAX_BFCACHE_SLOT_ENTRIES_WITH_CACHE_COMPONENTS : MAX_BFCACHE_SLOT_ENTRIES_WITHOUT_CACHE_COMPONENTS;

package/dist/shims/unified-request-context.js

@@ -18,6 +18,7 @@ function createRequestContext(opts) {
 		actionRevalidationKind: 0,
 		dynamicUsageDetected: false,
 		renderRequestApiUsage: /* @__PURE__ */ new Set(),
+		connectionProbe: null,
 		invalidDynamicUsageError: null,
 		pendingSetCookies: [],
 		draftModeCookieHeader: null,

package/dist/typegen.js

@@ -1,6 +1,7 @@
 import { decodeRouteSegment, isInvisibleSegment } from "./routing/utils.js";
 import { patternToNextFormat } from "./routing/route-validation.js";
 import { compareStrings } from "./utils/compare.js";
+import "./routing/app-route-graph.js";
 import { appRouteGraph } from "./routing/app-router.js";
 import path from "node:path";
 import fs from "node:fs/promises";

package/dist/utils/client-build-manifest.js

@@ -47,16 +47,26 @@ function findEntryFileFromManifest(buildManifest, assetBase, markers, fallbackTo
 	const chosen = fallbackToFirstEntry ? entries[0] : void 0;
 	return chosen ? manifestFileWithBase(chosen.file, assetBase) : void 0;
 }
+function listFilesRecursive(dir) {
+	const out = [];
+	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+		const full = path.join(dir, entry.name);
+		if (entry.isDirectory()) out.push(...listFilesRecursive(full));
+		else if (entry.isFile()) out.push(full);
+	}
+	return out;
+}
 function findClientEntryFileInAssetsDir(options) {
 	const assetsDir = path.join(options.clientDir, options.assetsSubdir);
 	if (!fs.existsSync(assetsDir)) return void 0;
-	const files = fs.readdirSync(assetsDir);
-	let entry;
+	const files = listFilesRecursive(assetsDir);
+	let entryFull;
 	for (const marker of options.markers) {
-		entry = files.find((file) => file.includes(marker) && file.endsWith(".js"));
-		if (entry) break;
+		entryFull = files.find((file) => path.basename(file).includes(marker) && file.endsWith(".js"));
+		if (entryFull) break;
 	}
-	return entry ? manifestFileWithBase(`${options.assetsSubdir}/${entry}`, options.assetBase) : void 0;
+	if (!entryFull) return void 0;
+	return manifestFileWithBase(path.relative(options.clientDir, entryFull).split(path.sep).join("/"), options.assetBase);
 }
 function findClientEntryFile(options) {
 	return (options.buildManifest ? findClientEntryFileFromManifest(options.buildManifest, options.assetBase) : void 0) ?? findClientEntryFileInAssetsDir({

package/dist/utils/client-runtime-metadata.d.ts

@@ -0,0 +1,45 @@
+//#region src/utils/client-runtime-metadata.d.ts
+type ClientRuntimeMetadata = {
+  clientEntryFile?: string;
+  lazyChunks?: string[];
+  dynamicPreloads?: Record<string, string[]>;
+};
+/**
+ * Read the client build manifest and compute runtime metadata used by
+ * Cloudflare worker entry injection and Node production server startup.
+ *
+ * - `lazyChunks` — chunks only reachable through dynamic `import()`, excluded
+ *   from modulepreload hints.
+ * - `dynamicPreloads` — per-module JS/CSS files for rendered `next/dynamic()`
+ *   boundaries, injected as preload links during SSR.
+ * - `clientEntryFile` — the client entry chunk filename (optional, only
+ *   needed for Pages Router).
+ *
+ * All file paths are normalised with the configured `assetBase` (basePath)
+ * and `assetPrefix`.
+ */
+declare function computeClientRuntimeMetadata(opts: {
+  clientDir: string;
+  assetBase: string;
+  assetPrefix: string;
+  includeClientEntry?: boolean | "pages-client-entry";
+}): ClientRuntimeMetadata;
+/**
+ * Serialize runtime metadata into the `globalThis.__VINEXT_*` assignment script
+ * that the Cloudflare `closeBundle` hook prepends to the worker entry. Returns
+ * `""` when there is nothing to inject.
+ *
+ * Both the App Router and Pages Router closeBundle paths call this (and the
+ * deploy tests mirror it), so the injection shape stays in one place. The caller
+ * decides which fields to pass — e.g. App Router only forwards `clientEntryFile`
+ * for mixed app+pages builds (where `computeClientRuntimeMetadata` was asked for
+ * the Pages client entry); pure App Router leaves it undefined.
+ */
+declare function buildRuntimeGlobalsScript(input: {
+  clientEntryFile?: string | null;
+  ssrManifest?: Record<string, string[]> | null;
+  lazyChunks?: string[] | null;
+  dynamicPreloads?: Record<string, string[]> | null;
+}): string;
+//#endregion
+export { buildRuntimeGlobalsScript, computeClientRuntimeMetadata };

package/dist/utils/client-runtime-metadata.js

@@ -0,0 +1,63 @@
+import { resolveAssetsDir } from "./asset-prefix.js";
+import { manifestFileWithAssetPrefix, manifestFileWithBase } from "./manifest-paths.js";
+import { findClientEntryFile, findPagesClientEntryFile, readClientBuildManifest } from "./client-build-manifest.js";
+import { findClientEntryFileFromVinextManifest, findPagesClientEntryFileFromVinextManifest, readClientEntryManifest } from "./client-entry-manifest.js";
+import { computeDynamicImportPreloads, computeLazyChunks, dynamicImportPreloadsWithBase } from "./lazy-chunks.js";
+import path from "node:path";
+//#region src/utils/client-runtime-metadata.ts
+/**
+* Read the client build manifest and compute runtime metadata used by
+* Cloudflare worker entry injection and Node production server startup.
+*
+* - `lazyChunks` — chunks only reachable through dynamic `import()`, excluded
+*   from modulepreload hints.
+* - `dynamicPreloads` — per-module JS/CSS files for rendered `next/dynamic()`
+*   boundaries, injected as preload links during SSR.
+* - `clientEntryFile` — the client entry chunk filename (optional, only
+*   needed for Pages Router).
+*
+* All file paths are normalised with the configured `assetBase` (basePath)
+* and `assetPrefix`.
+*/
+function computeClientRuntimeMetadata(opts) {
+	const buildManifest = readClientBuildManifest(path.join(opts.clientDir, ".vite", "manifest.json"));
+	const metadata = {};
+	if (opts.includeClientEntry) {
+		const clientEntryManifest = readClientEntryManifest(opts.clientDir);
+		const entryOptions = {
+			buildManifest,
+			clientDir: opts.clientDir,
+			assetsSubdir: resolveAssetsDir(opts.assetPrefix),
+			assetBase: opts.assetBase
+		};
+		const entry = opts.includeClientEntry === "pages-client-entry" ? findPagesClientEntryFileFromVinextManifest(clientEntryManifest, opts.assetBase) ?? findPagesClientEntryFile(entryOptions) : findClientEntryFileFromVinextManifest(clientEntryManifest, opts.assetBase) ?? findClientEntryFile(entryOptions);
+		if (entry) metadata.clientEntryFile = entry;
+	}
+	if (!buildManifest) return metadata;
+	const lazyChunks = computeLazyChunks(buildManifest).map((file) => manifestFileWithBase(file, opts.assetBase));
+	if (lazyChunks.length > 0) metadata.lazyChunks = lazyChunks;
+	const dynamicPreloads = dynamicImportPreloadsWithBase(computeDynamicImportPreloads(buildManifest), (file) => manifestFileWithAssetPrefix(file, opts.assetBase, opts.assetPrefix));
+	if (Object.keys(dynamicPreloads).length > 0) metadata.dynamicPreloads = dynamicPreloads;
+	return metadata;
+}
+/**
+* Serialize runtime metadata into the `globalThis.__VINEXT_*` assignment script
+* that the Cloudflare `closeBundle` hook prepends to the worker entry. Returns
+* `""` when there is nothing to inject.
+*
+* Both the App Router and Pages Router closeBundle paths call this (and the
+* deploy tests mirror it), so the injection shape stays in one place. The caller
+* decides which fields to pass — e.g. App Router only forwards `clientEntryFile`
+* for mixed app+pages builds (where `computeClientRuntimeMetadata` was asked for
+* the Pages client entry); pure App Router leaves it undefined.
+*/
+function buildRuntimeGlobalsScript(input) {
+	const globals = [];
+	if (input.clientEntryFile) globals.push(`globalThis.__VINEXT_CLIENT_ENTRY__ = ${JSON.stringify(input.clientEntryFile)};`);
+	if (input.ssrManifest && Object.keys(input.ssrManifest).length > 0) globals.push(`globalThis.__VINEXT_SSR_MANIFEST__ = ${JSON.stringify(input.ssrManifest)};`);
+	if (input.lazyChunks && input.lazyChunks.length > 0) globals.push(`globalThis.__VINEXT_LAZY_CHUNKS__ = ${JSON.stringify(input.lazyChunks)};`);
+	if (input.dynamicPreloads && Object.keys(input.dynamicPreloads).length > 0) globals.push(`globalThis.__VINEXT_DYNAMIC_PRELOADS__ = ${JSON.stringify(input.dynamicPreloads)};`);
+	return globals.join("\n");
+}
+//#endregion
+export { buildRuntimeGlobalsScript, computeClientRuntimeMetadata };

package/dist/utils/hash.d.ts

@@ -2,7 +2,23 @@
 /**
  * FNV-1a hash producing a 64-bit result (two 32-bit rounds with different seeds).
  * Used for deterministic key generation where collisions must be rare.
+ *
+ * This is a vinext-internal format: nothing outside vinext ever compares
+ * these values, so the algorithm only needs to be deterministic. For values
+ * that must be byte-for-byte identical to what Next.js emits (ETags), use
+ * `fnv1a52` below instead — the two are NOT interchangeable.
  */
 declare function fnv1a64(input: string): string;
+/**
+ * FNV-1a hash producing a 52-bit result, a byte-for-byte port of Next.js's
+ * `fnv1a52` in packages/next/src/server/lib/etag.ts (itself derived from
+ * fnv-plus). Used for ETag generation, where matching Next.js's exact output
+ * matters: clients and CDNs holding `If-None-Match` values from a Next.js
+ * deployment keep revalidating (304) against vinext for unchanged payloads.
+ *
+ * Deliberately separate from `fnv1a64` above — that one is a vinext-internal
+ * key format and produces different values. Do not swap one for the other.
+ */
+declare function fnv1a52(str: string): number;
 //#endregion
-export { fnv1a64 };
+export { fnv1a52, fnv1a64 };

package/dist/utils/hash.js

@@ -2,6 +2,11 @@
 /**
 * FNV-1a hash producing a 64-bit result (two 32-bit rounds with different seeds).
 * Used for deterministic key generation where collisions must be rare.
+*
+* This is a vinext-internal format: nothing outside vinext ever compares
+* these values, so the algorithm only needs to be deterministic. For values
+* that must be byte-for-byte identical to what Next.js emits (ETags), use
+* `fnv1a52` below instead — the two are NOT interchangeable.
 */
 function fnv1a64(input) {
 	let h1 = 2166136261;
@@ -16,5 +21,35 @@ function fnv1a64(input) {
 	}
 	return h1.toString(16).padStart(8, "0") + h2.toString(16).padStart(8, "0");
 }
+/**
+* FNV-1a hash producing a 52-bit result, a byte-for-byte port of Next.js's
+* `fnv1a52` in packages/next/src/server/lib/etag.ts (itself derived from
+* fnv-plus). Used for ETag generation, where matching Next.js's exact output
+* matters: clients and CDNs holding `If-None-Match` values from a Next.js
+* deployment keep revalidating (304) against vinext for unchanged payloads.
+*
+* Deliberately separate from `fnv1a64` above — that one is a vinext-internal
+* key format and produces different values. Do not swap one for the other.
+*/
+function fnv1a52(str) {
+	const len = str.length;
+	let i = 0, t0 = 0, v0 = 8997, t1 = 0, v1 = 33826, t2 = 0, v2 = 40164, t3 = 0, v3 = 52210;
+	while (i < len) {
+		v0 ^= str.charCodeAt(i++);
+		t0 = v0 * 435;
+		t1 = v1 * 435;
+		t2 = v2 * 435;
+		t3 = v3 * 435;
+		t2 += v0 << 8;
+		t3 += v1 << 8;
+		t1 += t0 >>> 16;
+		v0 = t0 & 65535;
+		t2 += t1 >>> 16;
+		v1 = t1 & 65535;
+		v3 = t3 + (t2 >>> 16) & 65535;
+		v2 = t2 & 65535;
+	}
+	return (v3 & 15) * 281474976710656 + v2 * 4294967296 + v1 * 65536 + (v0 ^ v3 >> 4);
+}
 //#endregion
-export { fnv1a64 };
+export { fnv1a52, fnv1a64 };

package/dist/utils/lazy-chunks.d.ts

@@ -29,5 +29,31 @@ type BuildManifestChunk = {
  *   should be excluded from modulepreload hints.
  */
 declare function computeLazyChunks(buildManifest: Record<string, BuildManifestChunk>): string[];
+/**
+ * Compute the production preload files for each module referenced by a
+ * `next/dynamic()` boundary.
+ *
+ * Next.js records module IDs during compilation, then resolves those IDs
+ * against its react-loadable manifest at render time. Vinext's equivalent
+ * source of truth is Vite's build manifest: each chunk lists the modules it
+ * reaches through `dynamicImports`, and each dynamic entry lists the JS/CSS
+ * files required to evaluate it.
+ *
+ * Note on shared chunks: a boundary's static-import tree (`collectStaticChunkFiles`)
+ * can include chunks that the page entry ALSO loads eagerly (a shared vendor
+ * chunk imported by both). Those files are intentionally NOT subtracted here, so
+ * a rendered boundary may emit a `<link rel="preload">` / `<link rel="stylesheet">`
+ * for a chunk the page already `<link rel="modulepreload">`s. This is harmless —
+ * the browser dedupes preloads by URL, `ReactDOM.preload()` dedupes script hints,
+ * and React's stylesheet resource model dedupes by href + precedence — and it
+ * mirrors Next.js listing a module's full file set in its react-loadable
+ * manifest. Subtracting the eager set would couple this to the entry's import
+ * closure for no correctness gain.
+ *
+ * @returns A map keyed by root-relative module ID, with JS/CSS files that
+ * should be preloaded when that dynamic boundary is rendered.
+ */
+declare function computeDynamicImportPreloads(buildManifest: Record<string, BuildManifestChunk>): Record<string, string[]>;
+declare function dynamicImportPreloadsWithBase(preloads: Record<string, string[]>, applyBase: (file: string) => string): Record<string, string[]>;
 //#endregion
-export { BuildManifestChunk, computeLazyChunks };
+export { BuildManifestChunk, computeDynamicImportPreloads, computeLazyChunks, dynamicImportPreloadsWithBase };