vinext 0.1.0 → 0.1.2

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";
@@ -247,15 +247,19 @@ function _registerRouterStateAccessors(accessors) {
 function setSSRContext(ctx) {
 	_setSSRContextImpl(ctx);
 }
+const PAGES_NAVIGATION_NOTIFY_KEY = Symbol.for("vinext.navigation.pagesNavigationNotify");
 let _cachedClientPagesNavCtx = null;
 let _cachedClientPagesNavCtxKey = null;
-function _buildClientPagesNavigationContext(routePattern, resolvedPath, searchString) {
-	const cacheKey = `${routePattern}|${resolvedPath}|${searchString}`;
+function _buildClientPagesNavigationContext(routePattern, resolvedPath, searchString, isReady, nextData) {
+	const cacheKey = `${isReady ? "1" : "0"}|${routePattern}|${resolvedPath}|${searchString}`;
 	if (_cachedClientPagesNavCtxKey === cacheKey && _cachedClientPagesNavCtx) return _cachedClientPagesNavCtx;
+	const searchParams = isReady ? new URLSearchParams(searchString) : new URLSearchParams();
+	const params = isReady ? extractRouteParamsFromPath(routePattern, resolvedPath) ?? getRouteParamsFromQuery(routePattern, nextData?.query ?? {}) ?? {} : null;
+	const isAutoExportDynamic = nextData?.autoExport === true && extractRouteParamNames(routePattern).length > 0;
 	const ctx = {
-		pathname: resolvedPath,
-		searchParams: new URLSearchParams(searchString),
-		params: routePattern ? extractRouteParamsFromPath(routePattern, resolvedPath) ?? {} : {}
+		pathname: resolvePagesNavigationPathname(resolvedPath, nextData?.isFallback === true, isAutoExportDynamic, isReady),
+		searchParams,
+		params
 	};
 	_cachedClientPagesNavCtx = ctx;
 	_cachedClientPagesNavCtxKey = cacheKey;
@@ -284,27 +288,33 @@ function getPagesNavigationContext() {
 		if (!ssrCtx) return null;
 		const cached = _ssrPagesNavCtxCache.get(ssrCtx);
 		if (cached) return cached;
-		let searchParams;
+		let searchString = "";
 		let resolvedPath;
 		try {
 			const url = new URL(ssrCtx.asPath, "http://_");
-			searchParams = url.searchParams;
+			searchString = url.search;
 			resolvedPath = url.pathname;
 		} catch {
-			searchParams = new URLSearchParams();
 			resolvedPath = ssrCtx.pathname;
 		}
-		const params = extractRouteParamsFromPath(ssrCtx.pathname, resolvedPath) ?? {};
+		const isReady = ssrCtx.navigationIsReady ?? true;
+		const searchParams = isReady ? new URLSearchParams(searchString) : new URLSearchParams();
+		const params = isReady ? extractRouteParamsFromPath(ssrCtx.pathname, resolvedPath) ?? getRouteParamsFromQuery(ssrCtx.pathname, ssrCtx.query) ?? {} : null;
+		const isAutoExportDynamic = ssrCtx.nextData?.autoExport === true && extractRouteParamNames(ssrCtx.pathname).length > 0;
 		const ctx = {
-			pathname: resolvedPath,
+			pathname: resolvePagesNavigationPathname(resolvedPath, ssrCtx.isFallback === true, isAutoExportDynamic, isReady),
 			searchParams,
 			params
 		};
 		_ssrPagesNavCtxCache.set(ssrCtx, ctx);
 		return ctx;
 	}
+	if (!isPagesRouterDocumentActive()) return null;
 	const resolvedPath = stripBasePath(window.location.pathname, __basePath);
-	return _buildClientPagesNavigationContext(window.__NEXT_DATA__?.page ?? "", resolvedPath, window.location.search);
+	const nextData = window.__NEXT_DATA__;
+	const pattern = resolvePagesRoutePatternForPath(nextData?.page, resolvedPath);
+	if (!pattern) return null;
+	return _buildClientPagesNavigationContext(pattern, resolvedPath, window.location.search, isPagesRouterReady(), nextData);
 }
 /**
 * Extract param names from a Next.js route pattern.
@@ -321,9 +331,52 @@ function extractRouteParamNames(pattern) {
 	for (const m of colonMatches) names.push(m[1]);
 	return names;
 }
+/**
+* Resolve the `pathname` snapshot for the Pages Router navigation context.
+* Shared by the client and SSR branches of `getPagesNavigationContext` so both
+* runtimes derive identical null-ness — diverging here would reintroduce a
+* hydration mismatch. Returns `null` for a `getStaticPaths` fallback shell or a
+* pre-ready auto-export dynamic route (the live path is published once the
+* client router becomes ready).
+*/
+function resolvePagesNavigationPathname(resolvedPath, isFallback, isAutoExportDynamic, isReady) {
+	return isFallback || isAutoExportDynamic && !isReady ? null : resolvedPath;
+}
+let _cachedPagesRoutePatternKey = null;
+let _cachedPagesRoutePattern;
+function resolvePagesRoutePatternForPath(nextDataPage, resolvedPath) {
+	if (nextDataPage && extractRouteParamNames(nextDataPage).length > 0) return nextDataPage;
+	const cacheKey = `${nextDataPage ?? ""}|${resolvedPath}`;
+	if (_cachedPagesRoutePatternKey === cacheKey) return _cachedPagesRoutePattern;
+	let resolved = nextDataPage;
+	for (const pattern of window.__VINEXT_PAGE_PATTERNS__ ?? []) if (matchRoutePattern(splitPathSegments(resolvedPath), routePatternParts(pattern))) {
+		resolved = pattern;
+		break;
+	}
+	_cachedPagesRoutePatternKey = cacheKey;
+	_cachedPagesRoutePattern = resolved;
+	return resolved;
+}
 function extractRouteParamsFromPath(pattern, pathname) {
 	return matchRoutePattern(splitPathSegments(pathname), routePatternParts(pattern));
 }
+function getRouteParamsFromQuery(pattern, query) {
+	const names = extractRouteParamNames(pattern);
+	if (names.length === 0) return null;
+	const params = {};
+	let hasParam = false;
+	for (const name of names) {
+		const value = query[name];
+		if (typeof value === "string") {
+			params[name] = value;
+			hasParam = true;
+		} else if (Array.isArray(value)) {
+			params[name] = [...value];
+			hasParam = true;
+		}
+	}
+	return hasParam ? params : null;
+}
 function getRouteQueryFromNextData(nextData, resolvedPath) {
 	const routeQuery = {};
 	if (!nextData?.query || !nextData.page) return routeQuery;
@@ -372,6 +425,47 @@ function getPathnameAndQuery() {
 		asPath: resolvedPath + window.location.search + window.location.hash
 	};
 }
+function getPagesNavigationIsReadyFromSerializedState(routePattern, searchString, nextData) {
+	if (!routePattern) return true;
+	if (nextData?.gssp === true || nextData?.gip === true || nextData?.isExperimentalCompile === true || nextData?.appGip === true && nextData.gsp !== true) return true;
+	const autoExportDynamic = nextData?.autoExport === true && extractRouteParamNames(routePattern).length > 0;
+	const hasSearch = searchString.length > 0;
+	const hasRewrites = nextData?.__vinext?.hasRewrites === true;
+	return !autoExportDynamic && !hasSearch && !hasRewrites;
+}
+function shouldDeferInitialPagesRouterReady() {
+	if (typeof window === "undefined") return false;
+	const nextData = window.__NEXT_DATA__;
+	if (!nextData) return false;
+	return !getPagesNavigationIsReadyFromSerializedState(nextData.page, window.location.search, nextData);
+}
+let _pagesRouterReady = typeof window === "undefined" ? true : !shouldDeferInitialPagesRouterReady();
+function isPagesRouterReady() {
+	return _pagesRouterReady;
+}
+function isPagesRouterDocumentActive() {
+	if (typeof window === "undefined") return true;
+	if (window.__VINEXT_PAGE_LOADERS__) return true;
+	if (window.next?.appDir === true) return false;
+	if (window.next?.router) return true;
+	return Boolean(window.__VINEXT_APP__ || window.__VINEXT_APP_LOADER__);
+}
+function markPagesRouterReady() {
+	if (typeof window === "undefined" || _pagesRouterReady) return false;
+	_pagesRouterReady = true;
+	return true;
+}
+function getRouterSnapshot() {
+	const isReady = typeof window === "undefined" ? _getSSRContext()?.navigationIsReady ?? true : isPagesRouterReady();
+	return {
+		...getPathnameAndQuery(),
+		isReady
+	};
+}
+function notifyNextNavigationPagesContext() {
+	const notify = globalThis[PAGES_NAVIGATION_NOTIFY_KEY];
+	notify?.();
+}
 /**
 * Error thrown when a navigation is superseded by a newer one.
 * Matches Next.js's convention of an Error with `.cancelled = true`.
@@ -779,7 +873,7 @@ async function runNavigateClient(fullUrl, resolvedUrl, fetchUrl = fullUrl, optio
 * and a set of navigation methods. Shared by the Pages Router context provider
 * and tests so the public router shape stays in sync.
 */
-function buildRouterValue(pathname, query, asPath, methods) {
+function buildRouterValue(pathname, query, asPath, isReady, methods) {
 	const _ssrState = _getSSRContext();
 	const nextData = typeof window !== "undefined" ? window.__NEXT_DATA__ : void 0;
 	const locale = typeof window === "undefined" ? _ssrState?.locale : window.__VINEXT_LOCALE__;
@@ -796,7 +890,7 @@ function buildRouterValue(pathname, query, asPath, methods) {
 		locales,
 		defaultLocale,
 		domainLocales,
-		isReady: true,
+		isReady,
 		isPreview: false,
 		isFallback: typeof window !== "undefined" ? nextData?.isFallback === true : _ssrState?.isFallback === true,
 		...methods,
@@ -815,6 +909,7 @@ function stripHash(url) {
 }
 /** Notify in-page listeners (e.g. useRouter hooks) that navigation occurred. */
 function dispatchNavigateEvent() {
+	notifyNextNavigationPagesContext();
 	window.dispatchEvent(new CustomEvent("vinext:navigate"));
 }
 /**
@@ -922,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 });
@@ -984,15 +1087,25 @@ function useRouter() {
 	return router;
 }
 function PagesRouterProvider({ children }) {
-	const [{ pathname, query, asPath }, setState] = useState(getPathnameAndQuery);
+	const [{ pathname, query, asPath, isReady }, setState] = useState(getRouterSnapshot);
 	useEffect(() => {
 		const onNavigate = ((_e) => {
-			setState(getPathnameAndQuery());
+			setState(getRouterSnapshot());
 		});
 		window.addEventListener("vinext:navigate", onNavigate);
-		return () => window.removeEventListener("vinext:navigate", onNavigate);
+		let cancelled = false;
+		const readyTimer = window.setTimeout(() => {
+			if (cancelled || !markPagesRouterReady()) return;
+			setState(getRouterSnapshot());
+			notifyNextNavigationPagesContext();
+		}, 0);
+		return () => {
+			cancelled = true;
+			window.clearTimeout(readyTimer);
+			window.removeEventListener("vinext:navigate", onNavigate);
+		};
 	}, []);
-	const router = useMemo(() => buildRouterValue(pathname, query, asPath, {
+	const router = useMemo(() => buildRouterValue(pathname, query, asPath, isReady, {
 		push: Router.push,
 		replace: Router.replace,
 		back: Router.back,
@@ -1002,7 +1115,8 @@ function PagesRouterProvider({ children }) {
 	}), [
 		pathname,
 		query,
-		asPath
+		asPath,
+		isReady
 	]);
 	const appRouter = useMemo(() => ({
 		bfcacheId: "0",
@@ -1215,8 +1329,9 @@ const Router = Object.defineProperties(RouterMethods, {
 	},
 	isReady: {
 		enumerable: true,
-		value: true,
-		writable: false
+		get() {
+			return isPagesRouterReady();
+		}
 	},
 	isPreview: {
 		enumerable: true,
@@ -1231,8 +1346,27 @@ 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;
 //#endregion
-export { _registerRouterStateAccessors, applyNavigationLocale, Router as default, getPagesNavigationContext, isExternalUrl, isHashOnlyChange, setSSRContext, useRouter, withRouter, wrapWithRouterContext };
+export { _registerRouterStateAccessors, applyNavigationLocale, Router as default, getPagesNavigationContext, getPagesNavigationIsReadyFromSerializedState, isExternalUrl, isHashOnlyChange, setSSRContext, useRouter, withRouter, wrapWithRouterContext };

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.d.ts

@@ -4,11 +4,18 @@ import { BuildManifestChunk } from "./lazy-chunks.js";
 type ClientBuildManifest = Record<string, BuildManifestChunk>;
 declare function readClientBuildManifest(manifestPath: string): ClientBuildManifest | undefined;
 declare function findClientEntryFileFromManifest(buildManifest: ClientBuildManifest, assetBase: string): string | undefined;
+declare function findPagesClientEntryFileFromManifest(buildManifest: ClientBuildManifest, assetBase: string): string | undefined;
 declare function findClientEntryFile(options: {
   buildManifest?: ClientBuildManifest;
   clientDir: string;
   assetsSubdir: string;
   assetBase: string;
 }): string | undefined;
+declare function findPagesClientEntryFile(options: {
+  buildManifest?: ClientBuildManifest;
+  clientDir: string;
+  assetsSubdir: string;
+  assetBase: string;
+}): string | undefined;
 //#endregion
-export { findClientEntryFile, findClientEntryFileFromManifest, readClientBuildManifest };
+export { findClientEntryFile, findClientEntryFileFromManifest, findPagesClientEntryFile, findPagesClientEntryFileFromManifest, readClientBuildManifest };

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

@@ -3,7 +3,8 @@ import { manifestFileWithBase } from "./manifest-paths.js";
 import fs from "node:fs";
 import path from "node:path";
 //#region src/utils/client-build-manifest.ts
-const CLIENT_ENTRY_MARKERS = ["vinext-client-entry", "vinext-app-browser-entry"];
+const PAGES_CLIENT_ENTRY_MARKERS = ["vinext-client-entry"];
+const CLIENT_ENTRY_MARKERS = [...PAGES_CLIENT_ENTRY_MARKERS, "vinext-app-browser-entry"];
 function readClientBuildManifest(manifestPath) {
 	if (!fs.existsSync(manifestPath)) return void 0;
 	try {
@@ -32,21 +33,55 @@ function readClientBuildManifest(manifestPath) {
 	}
 }
 function findClientEntryFileFromManifest(buildManifest, assetBase) {
+	return findEntryFileFromManifest(buildManifest, assetBase, CLIENT_ENTRY_MARKERS, true);
+}
+function findPagesClientEntryFileFromManifest(buildManifest, assetBase) {
+	return findEntryFileFromManifest(buildManifest, assetBase, PAGES_CLIENT_ENTRY_MARKERS, false);
+}
+function findEntryFileFromManifest(buildManifest, assetBase, markers, fallbackToFirstEntry) {
 	const entries = Object.values(buildManifest).filter((entry) => entry.isEntry && entry.file);
-	const chosen = entries.find((entry) => CLIENT_ENTRY_MARKERS.some((marker) => entry.file.includes(marker))) ?? entries[0];
+	for (const marker of markers) {
+		const markedEntry = entries.find((entry) => entry.file.includes(marker));
+		if (markedEntry) return manifestFileWithBase(markedEntry.file, assetBase);
+	}
+	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 entry = fs.readdirSync(assetsDir).find((file) => CLIENT_ENTRY_MARKERS.some((marker) => file.includes(marker)) && file.endsWith(".js"));
-	return entry ? manifestFileWithBase(`${options.assetsSubdir}/${entry}`, options.assetBase) : void 0;
+	const files = listFilesRecursive(assetsDir);
+	let entryFull;
+	for (const marker of options.markers) {
+		entryFull = files.find((file) => path.basename(file).includes(marker) && file.endsWith(".js"));
+		if (entryFull) break;
+	}
+	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(options);
+	return (options.buildManifest ? findClientEntryFileFromManifest(options.buildManifest, options.assetBase) : void 0) ?? findClientEntryFileInAssetsDir({
+		...options,
+		markers: CLIENT_ENTRY_MARKERS
+	});
+}
+function findPagesClientEntryFile(options) {
+	return (options.buildManifest ? findPagesClientEntryFileFromManifest(options.buildManifest, options.assetBase) : void 0) ?? findClientEntryFileInAssetsDir({
+		...options,
+		markers: PAGES_CLIENT_ENTRY_MARKERS
+	});
 }
 function readStringArray(value) {
 	return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
 }
 //#endregion
-export { findClientEntryFile, findClientEntryFileFromManifest, readClientBuildManifest };
+export { findClientEntryFile, findClientEntryFileFromManifest, findPagesClientEntryFile, findPagesClientEntryFileFromManifest, readClientBuildManifest };

package/dist/utils/client-entry-manifest.d.ts

@@ -0,0 +1,11 @@
+//#region src/utils/client-entry-manifest.d.ts
+declare const VINEXT_CLIENT_ENTRY_MANIFEST = "vinext-client-entry-manifest.json";
+type ClientEntryManifest = {
+  pagesClientEntry?: string;
+  appBrowserEntry?: string;
+};
+declare function readClientEntryManifest(clientDir: string): ClientEntryManifest | undefined;
+declare function findClientEntryFileFromVinextManifest(manifest: ClientEntryManifest | undefined, assetBase: string): string | undefined;
+declare function findPagesClientEntryFileFromVinextManifest(manifest: ClientEntryManifest | undefined, assetBase: string): string | undefined;
+//#endregion
+export { ClientEntryManifest, VINEXT_CLIENT_ENTRY_MANIFEST, findClientEntryFileFromVinextManifest, findPagesClientEntryFileFromVinextManifest, readClientEntryManifest };

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

@@ -0,0 +1,29 @@
+import { isUnknownRecord } from "./record.js";
+import { manifestFileWithBase } from "./manifest-paths.js";
+import fs from "node:fs";
+import path from "node:path";
+//#region src/utils/client-entry-manifest.ts
+const VINEXT_CLIENT_ENTRY_MANIFEST = "vinext-client-entry-manifest.json";
+function readClientEntryManifest(clientDir) {
+	const manifestPath = path.join(clientDir, VINEXT_CLIENT_ENTRY_MANIFEST);
+	if (!fs.existsSync(manifestPath)) return void 0;
+	try {
+		const value = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+		if (!isUnknownRecord(value)) return void 0;
+		const manifest = {};
+		if (typeof value.pagesClientEntry === "string") manifest.pagesClientEntry = value.pagesClientEntry;
+		if (typeof value.appBrowserEntry === "string") manifest.appBrowserEntry = value.appBrowserEntry;
+		return manifest.pagesClientEntry || manifest.appBrowserEntry ? manifest : void 0;
+	} catch {
+		return;
+	}
+}
+function findClientEntryFileFromVinextManifest(manifest, assetBase) {
+	const entry = manifest?.pagesClientEntry ?? manifest?.appBrowserEntry;
+	return entry ? manifestFileWithBase(entry, assetBase) : void 0;
+}
+function findPagesClientEntryFileFromVinextManifest(manifest, assetBase) {
+	return manifest?.pagesClientEntry ? manifestFileWithBase(manifest.pagesClientEntry, assetBase) : void 0;
+}
+//#endregion
+export { VINEXT_CLIENT_ENTRY_MANIFEST, findClientEntryFileFromVinextManifest, findPagesClientEntryFileFromVinextManifest, readClientEntryManifest };

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 };