vinext 1.2.1 → 1.3.1

package/dist/shims/router.js

@@ -1,4 +1,5 @@
 import { isUnknownRecord } from "../utils/record.js";
+import { execConfigSource } from "../config/config-source.js";
 import { parseCookieHeader } from "../utils/parse-cookie.js";
 import { isExternalUrl } from "../utils/external-url.js";
 import { hasBasePath, removeTrailingSlash, stripBasePath } from "../utils/base-path.js";
@@ -28,6 +29,7 @@ import { formatUrlObject, formatUrlObjectWithValidation } from "./internal/forma
 import { normalizeRouterHref, resolvePagesRouterHref } from "./internal/normalize-router-href.js";
 import { getCurrentRoutePathnameForWarning } from "./internal/route-pattern-for-warning.js";
 import { getCurrentBrowserLocale } from "./client-locale.js";
+import { clientRewriteAppendsParams } from "../client/client-rewrite-params.js";
 import { Component, Fragment, StrictMode, createElement, useContext, useEffect, useLayoutEffect, useMemo, useState } from "react";
 //#region src/shims/router.ts
 /**
@@ -975,7 +977,8 @@ function hasClientRedirectRules() {
 }
 function hasClientAppRouteManifest() {
 	const routes = window.__VINEXT_LINK_PREFETCH_ROUTES__;
-	return Array.isArray(routes) && routes.length > 0;
+	const routeHandlers = window.__VINEXT_APP_ROUTE_HANDLERS__;
+	return Array.isArray(routes) && routes.length > 0 || Array.isArray(routeHandlers) && routeHandlers.length > 0;
 }
 function getClientConfigRouteContext(href) {
 	let parsed;
@@ -1003,15 +1006,26 @@ function getClientConfigRouteContext(href) {
 		search: parsed.search
 	};
 }
+/**
+* matchRedirect has already applied basePath to a config destination, so a
+* local one that resolves outside it (`/../outside`, or a `basePath: false`
+* rule) is another app's URL. resolveLocalRedirectUrl would treat it as an app
+* path and re-add basePath, so it is followed as a document navigation instead,
+* landing where the server's redirect does.
+*/
+function configRedirectLeavesBasePath(location) {
+	if (!__basePath || !location.startsWith("/") || location.startsWith("//")) return false;
+	return !hasBasePath(new URL(location, "http://vinext.local").pathname, __basePath);
+}
 async function resolveClientConfigRedirect(href) {
 	const redirects = window.__VINEXT_CLIENT_REDIRECTS__;
 	if (!redirects || redirects.length === 0) return null;
 	const routeContext = getClientConfigRouteContext(href);
 	if (!routeContext) return null;
-	const [{ matchClientRedirect }, { preserveRedirectDestinationQuery }] = await Promise.all([import("../client/client-redirect-matcher.js"), import("../config/config-matchers.js")]);
+	const [{ matchClientRedirect }, { encodeRedirectLocation, preserveRedirectDestinationQuery }] = await Promise.all([import("../client/client-redirect-matcher.js"), import("../config/config-matchers.js")]);
 	const redirect = matchClientRedirect(routeContext.pathname, redirects, routeContext.context, routeContext.basePathState);
 	if (!redirect) return null;
-	return preserveRedirectDestinationQuery(__basePath && routeContext.basePathState.hadBasePath && !isExternalUrl(redirect.destination) && !hasBasePath(redirect.destination, __basePath) ? __basePath + redirect.destination : redirect.destination, routeContext.search, redirect.destinationQuery);
+	return encodeRedirectLocation(preserveRedirectDestinationQuery(redirect.destination, routeContext.search, redirect.destinationQuery));
 }
 async function applyClientConfigRewrite(href, rewrite) {
 	const routeContext = getClientConfigRouteContext(href);
@@ -1029,40 +1043,14 @@ function shouldEvaluateClientConfigRule(ruleBasePath, state) {
 	if (!state.basePath) return true;
 	return ruleBasePath === false ? !state.hadBasePath : state.hadBasePath;
 }
-function matchSimpleClientConfigPattern(pathname, source) {
-	if (source.includes("(") || source.includes("\\") || /:[\w-]+[*+][^/]/.test(source)) return;
-	const sourceParts = removeTrailingSlash(source).split("/");
-	const pathParts = removeTrailingSlash(pathname).split("/");
-	const params = {};
-	let pathIndex = 0;
-	for (let sourceIndex = 0; sourceIndex < sourceParts.length; sourceIndex++) {
-		const sourcePart = sourceParts[sourceIndex];
-		const pathPart = pathParts[pathIndex];
-		if (sourcePart.startsWith(":")) {
-			const catchAll = sourcePart.match(/^:([\w-]+)([*+])$/);
-			if (catchAll) {
-				const rest = pathParts.slice(pathIndex).join("/");
-				if (catchAll[2] === "+" && rest === "") return null;
-				params[catchAll[1]] = rest;
-				return sourceIndex === sourceParts.length - 1 ? params : void 0;
-			}
-			if (pathPart === void 0) return null;
-			params[sourcePart.slice(1)] = pathPart;
-			pathIndex++;
-			continue;
-		}
-		if (pathPart !== sourcePart) return null;
-		pathIndex++;
+function isSerializedRewriteDestination(destination) {
+	if (!destination.startsWith("/") || destination.startsWith("//")) return true;
+	try {
+		const parsed = new URL(destination, "http://n");
+		return parsed.pathname + parsed.search + parsed.hash === destination;
+	} catch {
+		return false;
 	}
-	return pathIndex === pathParts.length ? params : null;
-}
-function simpleClientConfigSourceCouldMatch(pathname, source) {
-	const wildcardIndex = source.search(/[:(\\*+?]/);
-	const literalPrefix = wildcardIndex === -1 ? source : source.slice(0, wildcardIndex);
-	const normalizedPrefix = removeTrailingSlash(literalPrefix);
-	if (!normalizedPrefix || normalizedPrefix === "/") return true;
-	const normalizedPathname = removeTrailingSlash(pathname);
-	return normalizedPathname === normalizedPrefix || normalizedPathname.startsWith(`${normalizedPrefix}/`);
 }
 function isExternalClientConfigUrl(url) {
 	return /^[a-z][a-z0-9+.-]*:/i.test(url) || url.startsWith("//");
@@ -1074,8 +1062,7 @@ function clientConfigRedirectCouldMatch(href) {
 	if (!routeContext) return false;
 	for (const redirect of redirects) {
 		if (!shouldEvaluateClientConfigRule(redirect.basePath, routeContext.basePathState)) continue;
-		if (!simpleClientConfigSourceCouldMatch(routeContext.pathname, redirect.source)) continue;
-		if (matchSimpleClientConfigPattern(routeContext.pathname, redirect.source) !== null) return true;
+		if (execConfigSource(routeContext.pathname, redirect.source) !== null) return true;
 	}
 	return false;
 }
@@ -1088,12 +1075,15 @@ function resolveClientConfigRewriteSync(href) {
 		const routeContext = getClientConfigRouteContext(currentHref);
 		if (!routeContext) return null;
 		if (!shouldEvaluateClientConfigRule(rewrite.basePath, routeContext.basePathState)) continue;
-		if (!simpleClientConfigSourceCouldMatch(routeContext.pathname, rewrite.source)) continue;
+		const match = execConfigSource(routeContext.pathname, rewrite.source);
+		if (match === null) continue;
 		if (rewrite.has || rewrite.requiresServerEvaluation) return void 0;
-		const params = matchSimpleClientConfigPattern(routeContext.pathname, rewrite.source);
-		if (params === void 0) return void 0;
-		if (params === null) continue;
+		if (match.unmatched.length > 0) return void 0;
+		const { params } = match;
+		if (!isSerializedRewriteDestination(rewrite.destination)) return void 0;
+		if (clientRewriteAppendsParams(rewrite.destination, params)) return void 0;
 		const rewritten = substituteDestinationParams(rewrite.destination, params, "rewrite");
+		if (!/^(?:https?:\/\/|\/(?![\\/\t\n\r]))/.test(rewritten)) return void 0;
 		if (isExternalClientConfigUrl(rewritten)) return { kind: "document" };
 		currentHref = mergeRewriteQuery(currentHref, rewritten);
 		matched = true;
@@ -1590,7 +1580,7 @@ async function navigateClient(url, fetchUrl = url, options = {}, routeUrl = url)
 			const routeMasked = options.routeMasked ?? routeUrl !== url;
 			const configRedirect = hasClientRedirectRules() && clientConfigRedirectCouldMatch(browserUrl) ? await resolveClientConfigRedirect(browserUrl) : null;
 			if (configRedirect) {
-				const redirectedUrl = resolveLocalRedirectUrl(configRedirect);
+				const redirectedUrl = configRedirectLeavesBasePath(configRedirect) ? null : resolveLocalRedirectUrl(configRedirect);
 				if (!redirectedUrl) scheduleHardNavigationAndThrow(configRedirect, "Navigation redirected externally");
 				throw new InternalNavigationRedirect(redirectedUrl);
 			}

package/dist/shims/server.d.ts

@@ -28,6 +28,11 @@ export type RequestInit = globalThis.RequestInit & {
     trailingSlash?: boolean;
     skipTrailingSlashRedirect?: boolean;
   };
+  /**
+   * vinext-internal: the host the request was made to, when the URL carries
+   * the server's own origin instead. It picks the i18n domain locale.
+   */
+  requestHost?: string;
   signal?: AbortSignal;
   duplex?: "half";
 };
@@ -100,6 +105,11 @@ export declare class NextResponse<_Body = unknown> extends Response {
 }
 export type NextURLConfig = {
   basePath?: string;
+  /**
+   * Request headers. As in Next.js's `getHostname`, a Host header decides the
+   * domain locale before the URL's own hostname.
+   */
+  headers?: Record<string, string | string[] | undefined>;
   nextConfig?: {
     i18n?: {
       locales: string[];
@@ -146,6 +156,12 @@ export declare class NextURL {
   private _locales;
   private _domains;
   private _domainLocale;
+  private _headers;
+  private _buildId;
+  /** First page segment of a raw data pathname, where its locale sits. */
+  private _dataPathSegment;
+  /** The locale parsed from that segment, if it is one. */
+  private _dataPathLocale;
   constructor(input: string | URL, base?: string | URL, config?: NextURLConfig);
   /**
    * With `skipTrailingSlashRedirect`, take the slash from the parsed pathname
@@ -164,9 +180,20 @@ export declare class NextURL {
    * middleware-base-path's "should execute from absolute paths" case.
    */
   private _stripBasePath;
+  /**
+   * Take the build ID from a raw `/_next/data/<buildId>/….json` pathname, as
+   * getNextPathnameInfo does. Middleware only sees one when proxy URL
+   * normalization is skipped; the pathname is left as is.
+   */
+  private _parseBuildId;
   /** Extract locale from pathname, stripping it from the internal URL. */
   private _detectPathnameLocale;
   private _analyzeI18n;
+  /**
+   * A raw data pathname keeps its locale segment, replaced by the current
+   * locale once it has been changed.
+   */
+  private _formatDataPathLocale;
   /**
    * Reconstruct the full pathname with basePath + locale prefix and apply
    * the configured trailingSlash policy.
@@ -214,10 +241,10 @@ export declare class NextURL {
   toString(): string;
   toJSON(): string;
   /**
-   * The build ID of the Next.js application.
-   * Set from `generateBuildId` in next.config.js, or a random UUID if not configured.
-   * Can be used in middleware to detect deployment skew between client and server.
-   * Matches the Next.js API: `request.nextUrl.buildId`.
+   * Matches the Next.js API: `request.nextUrl.buildId`. Next.js derives it
+   * from the URL (only `/_next/data/<buildId>/…` paths carry one) and never
+   * from the deployment, so a Client Component reads the same value on the
+   * server and in the browser.
    */
   get buildId(): string | undefined;
 }

package/dist/shims/server.js

@@ -117,7 +117,7 @@ var NextRequest = class extends Request {
 	_cookies;
 	constructor(input, init) {
 		validateURL(typeof input !== "string" && "url" in input ? input.url : String(input));
-		const { nextConfig: _nextConfig, ...plainInit } = init ?? {};
+		const { nextConfig: _nextConfig, requestHost, ...plainInit } = init ?? {};
 		const requestInit = init instanceof Request ? requestInitFromRequest(init) : plainInit;
 		if (input instanceof Request) {
 			super(input, initWithoutInputBody(input, requestInit));
@@ -143,6 +143,7 @@ var NextRequest = class extends Request {
 		} : void 0;
 		const urlConfig = _nextConfig ? {
 			basePath: _nextConfig.basePath,
+			headers: requestHost === void 0 ? void 0 : { host: requestHost },
 			nextConfig: {
 				i18n,
 				trailingSlash: _nextConfig.trailingSlash,
@@ -293,6 +294,9 @@ var NextResponse = class NextResponse extends Response {
 		});
 	}
 };
+function isRawDataPathname(pathname) {
+	return pathname.startsWith("/_next/data/") && pathname.endsWith(".json");
+}
 var NextURL = class NextURL {
 	/** Internal URL stores the pathname WITHOUT basePath or locale prefix. */
 	_url;
@@ -312,8 +316,15 @@ var NextURL = class NextURL {
 	_locales;
 	_domains;
 	_domainLocale;
+	_headers;
+	_buildId;
+	/** First page segment of a raw data pathname, where its locale sits. */
+	_dataPathSegment;
+	/** The locale parsed from that segment, if it is one. */
+	_dataPathLocale;
 	constructor(input, base, config) {
 		this._url = new URL(input.toString(), base);
+		this._headers = config?.headers;
 		this._configBasePath = config?.basePath ?? "";
 		this._basePath = this._configBasePath;
 		this._configTrailingSlash = config?.nextConfig?.trailingSlash ?? false;
@@ -321,6 +332,7 @@ var NextURL = class NextURL {
 		this._trailingSlash = this._configTrailingSlash;
 		this._analyzeTrailingSlash();
 		this._stripBasePath();
+		this._parseBuildId();
 		const i18n = config?.nextConfig?.i18n;
 		if (i18n) {
 			this._locales = [...i18n.locales];
@@ -361,6 +373,22 @@ var NextURL = class NextURL {
 		this._basePath = this._configBasePath;
 		this._url.pathname = stripBasePath(this._url.pathname, this._configBasePath);
 	}
+	/**
+	* Take the build ID from a raw `/_next/data/<buildId>/….json` pathname, as
+	* getNextPathnameInfo does. Middleware only sees one when proxy URL
+	* normalization is skipped; the pathname is left as is.
+	*/
+	_parseBuildId() {
+		const { pathname } = this._url;
+		if (!isRawDataPathname(pathname)) {
+			this._buildId = void 0;
+			this._dataPathSegment = void 0;
+			return;
+		}
+		const [buildId, pageSegment] = pathname.slice(12, -5).split("/");
+		this._buildId = buildId;
+		this._dataPathSegment = pageSegment === "index" ? void 0 : pageSegment;
+	}
 	/** Extract locale from pathname, stripping it from the internal URL. */
 	_detectPathnameLocale(locales) {
 		const segments = this._url.pathname.split("/");
@@ -372,11 +400,29 @@ var NextURL = class NextURL {
 	_analyzeI18n() {
 		if (!this._locales || !this._configDefaultLocale) return;
 		const detectedLocale = this._detectPathnameLocale(this._locales);
+		this._dataPathLocale = void 0;
+		if (!detectedLocale && this._buildId && this._dataPathSegment) {
+			const candidate = this._dataPathSegment.toLowerCase();
+			this._dataPathLocale = this._locales.find((l) => l.toLowerCase() === candidate);
+		}
 		const detectedLocaleLower = detectedLocale?.toLowerCase();
-		const hostname = this._url.hostname.toLowerCase();
+		const hostHeader = this._headers?.host;
+		const hostname = (typeof hostHeader === "string" && hostHeader ? hostHeader.split(":", 1)[0] : this._url.hostname).toLowerCase();
 		this._domainLocale = this._domains?.find((domain) => domain.domain.split(":", 1)[0].toLowerCase() === hostname || detectedLocaleLower === domain.defaultLocale.toLowerCase() || domain.locales?.some((locale) => locale.toLowerCase() === detectedLocaleLower));
 		this._defaultLocale = this._domainLocale?.defaultLocale ?? this._configDefaultLocale;
-		this._locale = detectedLocale ?? this._defaultLocale;
+		this._locale = detectedLocale ?? this._dataPathLocale ?? this._defaultLocale;
+	}
+	/**
+	* A raw data pathname keeps its locale segment, replaced by the current
+	* locale once it has been changed.
+	*/
+	_formatDataPathLocale(pathname) {
+		if (!this._dataPathLocale || this._locale === this._dataPathLocale) return pathname;
+		if (!this._locale || !isRawDataPathname(pathname)) return pathname;
+		const segments = pathname.slice(12, -5).split("/");
+		if (segments[1]?.toLowerCase() !== this._dataPathLocale.toLowerCase()) return pathname;
+		segments[1] = this._locale;
+		return "/_next/data/" + segments.join("/") + ".json";
 	}
 	/**
 	* Reconstruct the full pathname with basePath + locale prefix and apply
@@ -385,9 +431,9 @@ var NextURL = class NextURL {
 	*/
 	_formatPathname() {
 		let prefix = this._basePath;
-		const inner = this._url.pathname;
+		const inner = this._formatDataPathLocale(this._url.pathname);
 		const innerLower = inner.toLowerCase();
-		if (!(innerLower === "/api" || innerLower.startsWith("/api/")) && this._locale && this._locale !== this._defaultLocale) prefix += "/" + this._locale;
+		if (!(innerLower === "/api" || innerLower.startsWith("/api/")) && !isRawDataPathname(inner) && this._locale && this._locale !== this._defaultLocale) prefix += "/" + this._locale;
 		const composed = !prefix ? inner : inner === "/" ? prefix : prefix + inner;
 		return this._applyTrailingSlash(composed);
 	}
@@ -415,6 +461,7 @@ var NextURL = class NextURL {
 		this._url.href = value;
 		this._analyzeTrailingSlash();
 		this._stripBasePath();
+		this._parseBuildId();
 		this._analyzeI18n();
 	}
 	get origin() {
@@ -526,6 +573,7 @@ var NextURL = class NextURL {
 		} else if (this._trailingSlash) nextConfig.trailingSlash = true;
 		const config = {
 			basePath: this._configBasePath,
+			headers: this._headers,
 			nextConfig: Object.keys(nextConfig).length > 0 ? nextConfig : void 0
 		};
 		return new NextURL(this.href, void 0, config);
@@ -537,13 +585,13 @@ var NextURL = class NextURL {
 		return this.href;
 	}
 	/**
-	* The build ID of the Next.js application.
-	* Set from `generateBuildId` in next.config.js, or a random UUID if not configured.
-	* Can be used in middleware to detect deployment skew between client and server.
-	* Matches the Next.js API: `request.nextUrl.buildId`.
+	* Matches the Next.js API: `request.nextUrl.buildId`. Next.js derives it
+	* from the URL (only `/_next/data/<buildId>/…` paths carry one) and never
+	* from the deployment, so a Client Component reads the same value on the
+	* server and in the browser.
 	*/
 	get buildId() {
-		return process.env.__VINEXT_BUILD_ID ?? void 0;
+		return this._buildId;
 	}
 };
 var RequestCookies = class {

package/dist/shims/thenable-params.d.ts

@@ -3,7 +3,12 @@ import { WellKnownProperty } from "./internal/thenable-well-known-properties.js"
 export type ThenableParams<T extends Record<string, unknown>> = Promise<T> & Omit<T, WellKnownProperty>;
 export type ThenableParamsObserver = Readonly<{
   observeParamAccess: (keys: readonly string[]) => void;
-  observeReactPromiseStatus?: boolean;
+  /**
+   * Runs when `then` is read, and when `catch` or `finally` is called (they
+   * read `then` on a native promise). Throwing here fails the read itself
+   * before React counts any pending work, as Next.js does.
+   */
+  observeThenRead?: () => void;
 }>;
 /** Serialize backing values without reading a framework fallback-key proxy. */
 export declare function getFallbackParamsSnapshot(value: unknown): Promise<Record<string, unknown>> | undefined;

package/dist/shims/thenable-params.js

@@ -117,14 +117,20 @@ function createThenableParams(obj, observer, fallbackShellState) {
 	const params = createThenableParamsProxy(promise, {
 		get(target, prop, receiver) {
 			if (isPromiseContinuation(prop)) {
+				if (prop === "then") observer?.observeThenRead?.();
 				const value = Reflect.get(target, prop, receiver);
 				if (typeof value !== "function") return value;
 				return (...args) => {
-					if (!fallbackParamNames) observeAllParamKeys(observer, plain);
+					if (prop !== "then") observer?.observeThenRead?.();
+					if (!fallbackParamNames) try {
+						observeAllParamKeys(observer, plain);
+					} catch (error) {
+						return Reflect.apply(value, Promise.reject(error), args);
+					}
 					return Reflect.apply(value, target, args);
 				};
 			}
-			if (prop === "status" && observer?.observeReactPromiseStatus === true) observeAllParamKeys(observer, plain);
+			if (prop === "reason" && Object.hasOwn(target, prop)) return Reflect.get(target, prop);
 			if (typeof prop === "string" && !isWellKnownProperty(prop)) observeParamKeys(observer, [prop]);
 			if (!isWellKnownProperty(prop) && hasParamProperty(plain, prop)) {
 				if (isFallbackParam(prop)) {
@@ -164,6 +170,9 @@ function createThenableParams(obj, observer, fallbackShellState) {
 		ownKeys() {
 			observeReadableParamKeys(observer, plain);
 			return Reflect.ownKeys(plain).filter((prop) => !isWellKnownProperty(prop));
+		},
+		set(target, prop, value) {
+			return Reflect.set(target, prop, value);
 		}
 	});
 	paramsState.set(params, {

package/dist/shims/unified-request-context.d.ts

@@ -21,6 +21,11 @@ import "./request-state-types.js";
 export type UnifiedRequestContext = {
   /** Cloudflare Workers ExecutionContext, or null on Node.js dev. */
   executionContext: ExecutionContextLike | null;
+  /**
+   * The host's client-connection signal for the incoming request, before any
+   * clone follows it. Null for requests vinext creates itself (regeneration).
+   */
+  requestSignal: AbortSignal | null;
   /** Per-request cache for cacheForRequest(). Keyed by factory function reference. */
   requestCache: WeakMap<(...args: any[]) => any, unknown>;
   /** Shared lifecycle state for work deferred until the response closes. */

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

@@ -1,5 +1,6 @@
 import { getOrCreateAls } from "./internal/als-registry.js";
 import { isFullyBufferedBody, markFullyBufferedBody, preserveFullyBufferedBodyMetadata } from "../server/fully-buffered-response.js";
+import { deferUntilStreamConsumed } from "../server/defer-until-stream-consumed.js";
 //#region src/shims/unified-request-context.ts
 const _REQUEST_CONTEXT_ALS_KEY = Symbol.for("vinext.requestContext.als");
 const _g = globalThis;
@@ -18,6 +19,7 @@ function createRequestContext(opts) {
 		headersContext: null,
 		actionRevalidationKind: 0,
 		cacheLifeSink: null,
+		pendingCdnTagInvalidations: [],
 		pendingRevalidatedTags: /* @__PURE__ */ new Set(),
 		pendingRevalidations: /* @__PURE__ */ new Set(),
 		dynamicUsageDetected: false,
@@ -50,6 +52,7 @@ function createRequestContext(opts) {
 		currentFetchDedupeEntries: /* @__PURE__ */ new Map(),
 		nextFetchId: 1,
 		executionContext: _getInheritedExecutionContext(),
+		requestSignal: null,
 		requestCache: /* @__PURE__ */ new WeakMap(),
 		afterContext: {
 			callbacks: [],
@@ -159,9 +162,8 @@ function closeAfterResponseWithBody(response, ctx) {
 		return response;
 	}
 	if (isFullyBufferedBody(response) && !requiresResponseCloseTracking(ctx)) return response;
-	const passthrough = new TransformStream();
-	response.body.pipeTo(passthrough.writable).then(() => void closeAfterResponse(ctx), () => void closeAfterResponse(ctx));
-	const wrapped = new Response(passthrough.readable, {
+	const body = deferUntilStreamConsumed(response.body, () => void closeAfterResponse(ctx));
+	const wrapped = new Response(body, {
 		status: response.status,
 		statusText: response.statusText,
 		headers: response.headers

package/dist/typegen.d.ts

@@ -10,4 +10,5 @@ export type GenerateRouteTypesResult = {
   nextEnvStatus: "created" | "updated" | "unchanged";
 };
 export declare function generateRouteTypes(options: GenerateRouteTypesOptions): Promise<GenerateRouteTypesResult>;
-//#endregion
+//#endregion
+export {};

package/dist/utils/asset-prefix.d.ts

@@ -92,4 +92,11 @@ export declare function assetPrefixPathname(assetPrefix: string): string;
  * @see https://github.com/vercel/next.js/blob/canary/packages/next/src/server/lib/router-server.ts
  */
 export declare function isNextStaticPath(pathname: string, basePath: string, assetPathPrefix: string): boolean;
+/**
+ * Whether `pathname` is a build asset under a path `assetPrefix`. Next.js adds
+ * a built-in beforeFiles rewrite from `${assetPrefix}/_next/:path+` into the
+ * basePath (`loadRewrites` in `packages/next/src/lib/load-custom-routes.ts`),
+ * so such a path resolves even when it lies outside the basePath.
+ */
+export declare function isAssetPrefixBuildAsset(pathname: string, assetPathPrefix: string): boolean;
 //#endregion

package/dist/utils/asset-prefix.js

@@ -118,5 +118,14 @@ function isNextStaticPath(pathname, basePath, assetPathPrefix) {
 	if (assetPathPrefix && (p === assetPathPrefix || p.startsWith(assetPathPrefix + "/"))) p = p.slice(assetPathPrefix.length) || "/";
 	return p.startsWith(`/${ASSET_PREFIX_URL_DIR}/`);
 }
+/**
+* Whether `pathname` is a build asset under a path `assetPrefix`. Next.js adds
+* a built-in beforeFiles rewrite from `${assetPrefix}/_next/:path+` into the
+* basePath (`loadRewrites` in `packages/next/src/lib/load-custom-routes.ts`),
+* so such a path resolves even when it lies outside the basePath.
+*/
+function isAssetPrefixBuildAsset(pathname, assetPathPrefix) {
+	return !!assetPathPrefix && (pathname === assetPathPrefix || pathname.startsWith(assetPathPrefix + "/")) && isNextStaticPath(pathname, "", assetPathPrefix);
+}
 //#endregion
-export { ASSET_PREFIX_URL_DIR, assetPrefixPathname, isAbsoluteAssetPrefix, isNextStaticPath, resolveAssetUrlPrefix, resolveAssetsDir };
+export { ASSET_PREFIX_URL_DIR, assetPrefixPathname, isAbsoluteAssetPrefix, isAssetPrefixBuildAsset, isNextStaticPath, resolveAssetUrlPrefix, resolveAssetsDir };

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

@@ -4,6 +4,8 @@ type ClientBuildManifest = Record<string, BuildManifestChunk>;
 export declare function readClientBuildManifest(manifestPath: string): ClientBuildManifest | undefined;
 export declare function findClientEntryFileFromManifest(buildManifest: ClientBuildManifest, assetBase: string): string | undefined;
 export declare function findPagesClientEntryFileFromManifest(buildManifest: ClientBuildManifest, assetBase: string): string | undefined;
+/** Whether a build-manifest entry is the Pages Router client entry. */
+export declare function isPagesClientEntryChunk(key: string, entry: BuildManifestChunk): boolean;
 export declare function findClientEntryFile(options: {
   buildManifest?: ClientBuildManifest;
   clientDir: string;
@@ -16,4 +18,5 @@ export declare function findPagesClientEntryFile(options: {
   assetsSubdir: string;
   assetBase: string;
 }): string | undefined;
-//#endregion
+//#endregion
+export {};

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

@@ -19,6 +19,8 @@ function readClientBuildManifest(manifestPath) {
 			const assets = readStringArray(entry.assets);
 			manifest[key] = {
 				file: entry.file,
+				...typeof entry.src === "string" ? { src: entry.src } : {},
+				...typeof entry.name === "string" ? { name: entry.name } : {},
 				...entry.isEntry === true ? { isEntry: true } : {},
 				...entry.isDynamicEntry === true ? { isDynamicEntry: true } : {},
 				...imports ? { imports } : {},
@@ -39,14 +41,26 @@ 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);
-	for (const marker of markers) {
-		const markedEntry = entries.find((entry) => entry.file.includes(marker));
-		if (markedEntry) return manifestFileWithBase(markedEntry.file, assetBase);
+	const entries = Object.entries(buildManifest).filter(([, entry]) => entry.isEntry && entry.file);
+	const matchers = [matchesEntryIdentity, (marker, _key, entry) => entry.file.includes(marker)];
+	for (const matches of matchers) for (const marker of markers) {
+		const markedEntry = entries.find(([key, entry]) => matches(marker, key, entry));
+		if (markedEntry) return manifestFileWithBase(markedEntry[1].file, assetBase);
 	}
-	const chosen = fallbackToFirstEntry ? entries[0] : void 0;
+	const chosen = fallbackToFirstEntry ? entries[0]?.[1] : void 0;
 	return chosen ? manifestFileWithBase(chosen.file, assetBase) : void 0;
 }
+function matchesEntryIdentity(marker, key, entry) {
+	return entry.name === marker || isVirtualEntryId(key, marker) || entry.src !== void 0 && isVirtualEntryId(entry.src, marker);
+}
+/** Whether a build-manifest entry is the Pages Router client entry. */
+function isPagesClientEntryChunk(key, entry) {
+	return entry.isEntry === true && PAGES_CLIENT_ENTRY_MARKERS.some((marker) => matchesEntryIdentity(marker, key, entry));
+}
+function isVirtualEntryId(id, marker) {
+	const virtualId = `virtual:${marker}`;
+	return id === virtualId || id.endsWith(`/${virtualId}`);
+}
 function listFilesRecursive(dir) {
 	const out = [];
 	for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
@@ -85,4 +99,4 @@ function readStringArray(value) {
 	return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
 }
 //#endregion
-export { findClientEntryFile, findClientEntryFileFromManifest, findPagesClientEntryFile, findPagesClientEntryFileFromManifest, readClientBuildManifest };
+export { findClientEntryFile, findClientEntryFileFromManifest, findPagesClientEntryFile, findPagesClientEntryFileFromManifest, isPagesClientEntryChunk, readClientBuildManifest };

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

@@ -1,10 +1,23 @@
+import { ClientReferenceChunks } from "./client-reference-chunks.js";
 //#region src/utils/client-entry-manifest.d.ts
 export declare const VINEXT_CLIENT_ENTRY_MANIFEST = "vinext-client-entry-manifest.json";
+/**
+ * Build manifest keys of App Router client reference modules -> the chunk of
+ * the module that registers the reference (see build/client-reference-chunks.ts).
+ * It names source files, so it sits under `.vite/` with Vite's build manifest,
+ * which deploys leave out of the public assets.
+ */
+export declare const VINEXT_CLIENT_REFERENCE_SOURCES = ".vite/vinext-client-reference-sources.json";
 export type ClientEntryManifest = {
   pagesClientEntry?: string;
   appBrowserEntry?: string;
+  /** The App Router RouteManifest chunk, which the browser entry imports as it boots. */
+  appRouteManifest?: string;
+  /** What each App Router client reference loads in the browser. */
+  appClientReferenceChunks?: ClientReferenceChunks;
 };
 export declare function readClientEntryManifest(clientDir: string): ClientEntryManifest | undefined;
+export declare function readClientReferenceSources(clientDir: string): Record<string, string> | undefined;
 export declare function findClientEntryFileFromVinextManifest(manifest: ClientEntryManifest | undefined, assetBase: string): string | undefined;
 export declare function findPagesClientEntryFileFromVinextManifest(manifest: ClientEntryManifest | undefined, assetBase: string): string | undefined;
 //#endregion

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

@@ -4,6 +4,13 @@ import { manifestFileWithBase } from "./manifest-paths.js";
 import fs from "node:fs";
 //#region src/utils/client-entry-manifest.ts
 const VINEXT_CLIENT_ENTRY_MANIFEST = "vinext-client-entry-manifest.json";
+/**
+* Build manifest keys of App Router client reference modules -> the chunk of
+* the module that registers the reference (see build/client-reference-chunks.ts).
+* It names source files, so it sits under `.vite/` with Vite's build manifest,
+* which deploys leave out of the public assets.
+*/
+const VINEXT_CLIENT_REFERENCE_SOURCES = ".vite/vinext-client-reference-sources.json";
 function readClientEntryManifest(clientDir) {
 	const manifestPath = path.join(clientDir, VINEXT_CLIENT_ENTRY_MANIFEST);
 	if (!fs.existsSync(manifestPath)) return void 0;
@@ -13,11 +20,23 @@ function readClientEntryManifest(clientDir) {
 		const manifest = {};
 		if (typeof value.pagesClientEntry === "string") manifest.pagesClientEntry = value.pagesClientEntry;
 		if (typeof value.appBrowserEntry === "string") manifest.appBrowserEntry = value.appBrowserEntry;
+		if (typeof value.appRouteManifest === "string") manifest.appRouteManifest = value.appRouteManifest;
+		if (isUnknownRecord(value.appClientReferenceChunks)) manifest.appClientReferenceChunks = value.appClientReferenceChunks;
 		return manifest.pagesClientEntry || manifest.appBrowserEntry ? manifest : void 0;
 	} catch {
 		return;
 	}
 }
+function readClientReferenceSources(clientDir) {
+	const sourcesPath = path.join(clientDir, VINEXT_CLIENT_REFERENCE_SOURCES);
+	if (!fs.existsSync(sourcesPath)) return void 0;
+	try {
+		const value = JSON.parse(fs.readFileSync(sourcesPath, "utf-8"));
+		return isUnknownRecord(value) ? value : void 0;
+	} catch {
+		return;
+	}
+}
 function findClientEntryFileFromVinextManifest(manifest, assetBase) {
 	const entry = manifest?.pagesClientEntry ?? manifest?.appBrowserEntry;
 	return entry ? manifestFileWithBase(entry, assetBase) : void 0;
@@ -26,4 +45,4 @@ function findPagesClientEntryFileFromVinextManifest(manifest, assetBase) {
 	return manifest?.pagesClientEntry ? manifestFileWithBase(manifest.pagesClientEntry, assetBase) : void 0;
 }
 //#endregion
-export { VINEXT_CLIENT_ENTRY_MANIFEST, findClientEntryFileFromVinextManifest, findPagesClientEntryFileFromVinextManifest, readClientEntryManifest };
+export { VINEXT_CLIENT_ENTRY_MANIFEST, VINEXT_CLIENT_REFERENCE_SOURCES, findClientEntryFileFromVinextManifest, findPagesClientEntryFileFromVinextManifest, readClientEntryManifest, readClientReferenceSources };