vinext 1.2.1 → 1.3.1

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/tiff.js

@@ -0,0 +1,96 @@
+import { readUInt, readUInt64, toHexString, toUTF8String } from "./utils.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/tiff.js
+const CONSTANTS = {
+	TAG: {
+		WIDTH: 256,
+		HEIGHT: 257,
+		COMPRESSION: 259
+	},
+	TYPE: {
+		SHORT: 3,
+		LONG: 4,
+		LONG8: 16
+	},
+	ENTRY_SIZE: {
+		STANDARD: 12,
+		BIG: 20
+	},
+	COUNT_SIZE: {
+		STANDARD: 2,
+		BIG: 8
+	}
+};
+function readIFD(input, { isBigEndian, isBigTiff }) {
+	const ifdOffset = isBigTiff ? Number(readUInt64(input, 8, isBigEndian)) : readUInt(input, 32, 4, isBigEndian);
+	const entryCountSize = isBigTiff ? CONSTANTS.COUNT_SIZE.BIG : CONSTANTS.COUNT_SIZE.STANDARD;
+	return input.slice(ifdOffset + entryCountSize);
+}
+function readTagValue(input, type, offset, isBigEndian) {
+	switch (type) {
+		case CONSTANTS.TYPE.SHORT: return readUInt(input, 16, offset, isBigEndian);
+		case CONSTANTS.TYPE.LONG: return readUInt(input, 32, offset, isBigEndian);
+		case CONSTANTS.TYPE.LONG8: {
+			const value = Number(readUInt64(input, offset, isBigEndian));
+			if (value > Number.MAX_SAFE_INTEGER) throw new TypeError("Value too large");
+			return value;
+		}
+		default: return 0;
+	}
+}
+function nextTag(input, isBigTiff) {
+	const entrySize = isBigTiff ? CONSTANTS.ENTRY_SIZE.BIG : CONSTANTS.ENTRY_SIZE.STANDARD;
+	if (input.length > entrySize) return input.slice(entrySize);
+}
+function extractTags(input, { isBigEndian, isBigTiff }) {
+	const tags = {};
+	let temp = input;
+	while (temp?.length) {
+		const code = readUInt(temp, 16, 0, isBigEndian);
+		const type = readUInt(temp, 16, 2, isBigEndian);
+		const length = isBigTiff ? Number(readUInt64(temp, 4, isBigEndian)) : readUInt(temp, 32, 4, isBigEndian);
+		if (code === 0) break;
+		if (length === 1 && (type === CONSTANTS.TYPE.SHORT || type === CONSTANTS.TYPE.LONG || isBigTiff && type === CONSTANTS.TYPE.LONG8)) tags[code] = readTagValue(temp, type, isBigTiff ? 12 : 8, isBigEndian);
+		temp = nextTag(temp, isBigTiff);
+	}
+	return tags;
+}
+function determineFormat(input) {
+	const signature = toUTF8String(input, 0, 2);
+	const version = readUInt(input, 16, 2, signature === "MM");
+	return {
+		isBigEndian: signature === "MM",
+		isBigTiff: version === 43
+	};
+}
+function validateBigTIFFHeader(input, isBigEndian) {
+	const byteSize = readUInt(input, 16, 4, isBigEndian);
+	const reserved = readUInt(input, 16, 6, isBigEndian);
+	if (byteSize !== 8 || reserved !== 0) throw new TypeError("Invalid BigTIFF header");
+}
+const signatures = /* @__PURE__ */ new Set([
+	"49492a00",
+	"4d4d002a",
+	"49492b00",
+	"4d4d002b"
+]);
+const TIFF = {
+	validate: (input) => {
+		const signature = toHexString(input, 0, 4);
+		return signatures.has(signature);
+	},
+	calculate(input) {
+		const format = determineFormat(input);
+		if (format.isBigTiff) validateBigTIFFHeader(input, format.isBigEndian);
+		const tags = extractTags(readIFD(input, format), format);
+		const info = {
+			height: tags[CONSTANTS.TAG.HEIGHT],
+			width: tags[CONSTANTS.TAG.WIDTH],
+			type: format.isBigTiff ? "bigtiff" : "tiff"
+		};
+		if (tags[CONSTANTS.TAG.COMPRESSION]) info.compression = tags[CONSTANTS.TAG.COMPRESSION];
+		if (!info.width || !info.height) throw new TypeError("Invalid Tiff. Missing tags");
+		return info;
+	}
+};
+//#endregion
+export { TIFF };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/utils.js

@@ -0,0 +1,53 @@
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/utils.js
+const decoder = new TextDecoder();
+const toUTF8String = (input, start = 0, end = input.length) => decoder.decode(input.slice(start, end));
+const toHexString = (input, start = 0, end = input.length) => input.slice(start, end).reduce((memo, i) => memo + `0${i.toString(16)}`.slice(-2), "");
+const getView = (input, offset) => new DataView(input.buffer, input.byteOffset + offset);
+const readInt16LE = (input, offset = 0) => getView(input, offset).getInt16(0, true);
+const readUInt16BE = (input, offset = 0) => getView(input, offset).getUint16(0, false);
+const readUInt16LE = (input, offset = 0) => getView(input, offset).getUint16(0, true);
+const readUInt24LE = (input, offset = 0) => {
+	const view = getView(input, offset);
+	return view.getUint16(0, true) + (view.getUint8(2) << 16);
+};
+const readInt32LE = (input, offset = 0) => getView(input, offset).getInt32(0, true);
+const readUInt32BE = (input, offset = 0) => getView(input, offset).getUint32(0, false);
+const readUInt32LE = (input, offset = 0) => getView(input, offset).getUint32(0, true);
+const readUInt64 = (input, offset, isBigEndian) => getView(input, offset).getBigUint64(0, !isBigEndian);
+const methods = {
+	readUInt16BE,
+	readUInt16LE,
+	readUInt32BE,
+	readUInt32LE
+};
+function readUInt(input, bits, offset = 0, isBigEndian = false) {
+	const methodName = `readUInt${bits}${isBigEndian ? "BE" : "LE"}`;
+	return methods[methodName](input, offset);
+}
+const BOX_HEADER_SIZE = 8;
+function readBox(input, offset) {
+	if (input.length - offset < BOX_HEADER_SIZE) return void 0;
+	const boxSize = readUInt32BE(input, offset);
+	if (input.length - offset < boxSize) return void 0;
+	return {
+		name: toUTF8String(input, 4 + offset, 8 + offset),
+		offset,
+		size: boxSize
+	};
+}
+function findBox(input, boxName, startOffset) {
+	let currentOffset = startOffset;
+	while (currentOffset < input.length) {
+		if (input.length - currentOffset < 4) break;
+		if (readUInt32BE(input, currentOffset) < BOX_HEADER_SIZE) {
+			currentOffset += BOX_HEADER_SIZE;
+			continue;
+		}
+		const box = readBox(input, currentOffset);
+		if (!box) break;
+		if (box.name === boxName) return box;
+		currentOffset += box.size;
+	}
+}
+//#endregion
+export { findBox, readInt16LE, readInt32LE, readUInt, readUInt16BE, readUInt16LE, readUInt24LE, readUInt32BE, readUInt32LE, readUInt64, toHexString, toUTF8String };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/types/webp.js

@@ -0,0 +1,45 @@
+import { readInt16LE, readUInt24LE, toHexString, toUTF8String } from "./utils.js";
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/types/webp.js
+function calculateExtended(input) {
+	return {
+		height: 1 + readUInt24LE(input, 7),
+		width: 1 + readUInt24LE(input, 4)
+	};
+}
+function calculateLossless(input) {
+	return {
+		height: 1 + ((input[4] & 15) << 10 | input[3] << 2 | (input[2] & 192) >> 6),
+		width: 1 + ((input[2] & 63) << 8 | input[1])
+	};
+}
+function calculateLossy(input) {
+	return {
+		height: readInt16LE(input, 8) & 16383,
+		width: readInt16LE(input, 6) & 16383
+	};
+}
+const WEBP = {
+	validate(input) {
+		const riffHeader = "RIFF" === toUTF8String(input, 0, 4);
+		const webpHeader = "WEBP" === toUTF8String(input, 8, 12);
+		const vp8Header = "VP8" === toUTF8String(input, 12, 15);
+		return riffHeader && webpHeader && vp8Header;
+	},
+	calculate(_input) {
+		const chunkHeader = toUTF8String(_input, 12, 16);
+		const input = _input.slice(20, 30);
+		if (chunkHeader === "VP8X") {
+			const extendedHeader = input[0];
+			const validStart = (extendedHeader & 192) === 0;
+			const validEnd = (extendedHeader & 1) === 0;
+			if (validStart && validEnd) return calculateExtended(input);
+			throw new TypeError("Invalid WebP");
+		}
+		if (chunkHeader === "VP8 " && input[0] !== 47) return calculateLossy(input);
+		const signature = toHexString(input, 3, 6);
+		if (chunkHeader === "VP8L" && signature !== "9d012a") return calculateLossless(input);
+		throw new TypeError("Invalid WebP");
+	}
+};
+//#endregion
+export { WEBP };

package/dist/deps/.pnpm/image-size@2.0.4/deps/image-size/dist/esm/utils/bit-reader.js

@@ -0,0 +1,38 @@
+//#region ../../node_modules/.pnpm/image-size@2.0.4/node_modules/image-size/dist/esm/utils/bit-reader.js
+var BitReader = class {
+	input;
+	endianness;
+	byteOffset = 2;
+	bitOffset = 0;
+	constructor(input, endianness) {
+		this.input = input;
+		this.endianness = endianness;
+	}
+	getBits(length = 1) {
+		let result = 0;
+		let bitsRead = 0;
+		while (bitsRead < length) {
+			if (this.byteOffset >= this.input.length) throw new Error("Reached end of input");
+			const currentByte = this.input[this.byteOffset];
+			const bitsLeft = 8 - this.bitOffset;
+			const bitsToRead = Math.min(length - bitsRead, bitsLeft);
+			if (this.endianness === "little-endian") {
+				const mask = (1 << bitsToRead) - 1;
+				const bits = currentByte >> this.bitOffset & mask;
+				result |= bits << bitsRead;
+			} else {
+				const bits = (currentByte & (1 << bitsToRead) - 1 << 8 - this.bitOffset - bitsToRead) >> 8 - this.bitOffset - bitsToRead;
+				result = result << bitsToRead | bits;
+			}
+			bitsRead += bitsToRead;
+			this.bitOffset += bitsToRead;
+			if (this.bitOffset === 8) {
+				this.byteOffset++;
+				this.bitOffset = 0;
+			}
+		}
+		return result;
+	}
+};
+//#endregion
+export { BitReader };

package/dist/deps/.pnpm/ua-parser-js@1.0.35/deps/ua-parser-js/src/ua-parser.js

@@ -1,6 +1,6 @@
 import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
 //#region ../../node_modules/.pnpm/ua-parser-js@1.0.35/node_modules/ua-parser-js/src/ua-parser.js
-var require_ua_parser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+var require_ua_parser = /* @__PURE__ */ __commonJSMin(((exports, module, this$1) => {
 	(function(window, undefined) {
 		"use strict";
 		var LIBVERSION = "1.0.35", EMPTY = "", UNKNOWN = "?", FUNC_TYPE = "function", UNDEF_TYPE = "undefined", OBJ_TYPE = "object", STR_TYPE = "string", MAJOR = "major", MODEL = "model", NAME = "name", TYPE = "type", VENDOR = "vendor", VERSION = "version", ARCHITECTURE = "architecture", CONSOLE = "console", MOBILE = "mobile", TABLET = "tablet", SMARTTV = "smarttv", WEARABLE = "wearable", EMBEDDED = "embedded", UA_MAX_LENGTH = 350, AMAZON = "Amazon", APPLE = "Apple", ASUS = "ASUS", BLACKBERRY = "BlackBerry", BROWSER = "Browser", CHROME = "Chrome", EDGE = "Edge", FIREFOX = "Firefox", GOOGLE = "Google", HUAWEI = "Huawei", LG = "LG", MICROSOFT = "Microsoft", MOTOROLA = "Motorola", OPERA = "Opera", SAMSUNG = "Samsung", SHARP = "Sharp", SONY = "Sony", XIAOMI = "Xiaomi", ZEBRA = "Zebra", FACEBOOK = "Facebook", CHROMIUM_OS = "Chromium OS", MAC_OS = "Mac OS";
@@ -1050,7 +1050,7 @@ var require_ua_parser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				for (var prop in result) $.ua[prop] = result[prop];
 			};
 		}
-	})(typeof window === "object" ? window : exports);
+	})(typeof window === "object" ? window : this$1);
 }));
 //#endregion
 export default require_ua_parser();

package/dist/entries/app-browser-entry.d.ts

@@ -9,13 +9,41 @@ import { VinextLinkPrefetchRoute, VinextPagesLinkPrefetchRoute } from "../client
  * embedded RSC payload and handles client-side navigation by re-fetching
  * RSC streams.
  */
-export declare function generateBrowserEntry(routes?: readonly AppRoute[], routeManifest?: RouteManifest | null, pagesPrefetchRoutes?: readonly VinextPagesLinkPrefetchRoute[], rewrites?: {
+export declare function generateBrowserEntry(routes?: readonly AppRoute[], pagesPrefetchRoutes?: readonly VinextPagesLinkPrefetchRoute[], rewrites?: {
   afterFiles: NextRewrite[];
   beforeFiles: NextRewrite[];
   fallback: NextRewrite[];
-}, locales?: readonly string[]): string;
+}, locales?: readonly string[], classifier?: AppRouteDynamicRenderClassifier): string;
+/**
+ * App route handlers for hybrid App/Pages ownership, with their static
+ * segments hashed so the client never receives their paths in plain text.
+ */
+export declare function toHashedRouteHandlerRoutes(routes: readonly AppRoute[]): VinextLinkPrefetchRoute[];
+type AppRouteIntercept = AppRoute["siblingIntercepts"][number];
+/** Reads, at build time, which App pages Next.js renders on every request. */
+export type AppRouteDynamicRenderClassifier = {
+  route(route: AppRoute): boolean;
+  /**
+   * `layoutPaths` holds the layouts above the intercepting page outside its
+   * own branch: the source route's, and the slot's.
+   */
+  intercept(intercept: AppRouteIntercept, layoutPaths: readonly string[]): boolean;
+};
 /** Project an `AppRoute` down to the public `VinextLinkPrefetchRoute` shape. */
-export declare function toLinkPrefetchRoute(route: AppRoute, hasSiblingInterceptLoading?: boolean): VinextLinkPrefetchRoute;
-/** Project App routes together so sibling-intercept loading is applied to its target route. */
-export declare function toLinkPrefetchRoutes(routes: readonly AppRoute[]): VinextLinkPrefetchRoute[];
-//#endregion
+export declare function toLinkPrefetchRoute(route: AppRoute, hasSiblingInterceptLoading?: boolean, rendersDynamically?: boolean): VinextLinkPrefetchRoute;
+/**
+ * Project App routes together so sibling-intercept loading is applied to its
+ * target route. `classifier` reads each route's segment config, and each
+ * intercepting page's, which applies to its target route.
+ */
+export declare function toLinkPrefetchRoutes(routes: readonly AppRoute[], classifier?: AppRouteDynamicRenderClassifier): VinextLinkPrefetchRoute[];
+/**
+ * Generate the virtual module that holds the browser RouteManifest.
+ *
+ * The App browser runtime imports it dynamically when hydration starts, so the
+ * manifest, which grows with every route, stays out of the entry chunk. The
+ * JSON string keeps the parse on V8's fast JSON path.
+ */
+export declare function generateBrowserRouteManifestModule(routeManifest: RouteManifest | null): string;
+//#endregion
+export {};

package/dist/entries/app-browser-entry.js

@@ -1,6 +1,8 @@
 import { patternsStructurallyEquivalent } from "../routing/app-route-graph.js";
 import { resolveClientRuntimeModule, resolveRuntimeEntryModule } from "./runtime-entry-module.js";
 import { toClientRewrites } from "../client/client-rewrites.js";
+import { hashRoutePatternParts } from "../routing/hashed-route-patterns.js";
+import { toBrowserRouteManifestWire } from "../routing/browser-route-manifest.js";
 //#region src/entries/app-browser-entry.ts
 /**
 * Generate the virtual browser entry module.
@@ -9,20 +11,20 @@ import { toClientRewrites } from "../client/client-rewrites.js";
 * embedded RSC payload and handles client-side navigation by re-fetching
 * RSC streams.
 */
-function generateBrowserEntry(routes = [], routeManifest = null, pagesPrefetchRoutes = [], rewrites = {
+function generateBrowserEntry(routes = [], pagesPrefetchRoutes = [], rewrites = {
 	afterFiles: [],
 	beforeFiles: [],
 	fallback: []
-}, locales = []) {
+}, locales = [], classifier) {
 	const entryPath = resolveRuntimeEntryModule("app-browser-entry");
 	const reactInstanceBootstrapPath = resolveClientRuntimeModule("react-instance-bootstrap");
-	const navigationRuntimePath = resolveClientRuntimeModule("navigation-runtime");
-	const prefetchRoutes = toLinkPrefetchRoutes(routes);
+	const prefetchRoutes = toLinkPrefetchRoutes(routes, classifier);
+	const routeHandlers = pagesPrefetchRoutes.length > 0 ? toHashedRouteHandlerRoutes(routes) : [];
 	const clientRewrites = toClientRewrites(rewrites);
 	return `import ${JSON.stringify(reactInstanceBootstrapPath)};
-import { registerNavigationRuntimeBootstrap } from ${JSON.stringify(navigationRuntimePath)};
 
 window.__VINEXT_LINK_PREFETCH_ROUTES__ = ${JSON.stringify(prefetchRoutes)};
+window.__VINEXT_APP_ROUTE_HANDLERS__ = ${JSON.stringify(routeHandlers)};
 // Pages route manifest for hybrid ownership decisions. In a hybrid
 // app+pages build the user can land on an App page, so the App browser
 // entry must also expose the Pages manifest (the Pages client entry does
@@ -30,9 +32,6 @@ window.__VINEXT_LINK_PREFETCH_ROUTES__ = ${JSON.stringify(prefetchRoutes)};
 window.__VINEXT_PAGES_LINK_PREFETCH_ROUTES__ = ${JSON.stringify(pagesPrefetchRoutes)};
 window.__VINEXT_CLIENT_REWRITES__ = ${JSON.stringify(clientRewrites)};
 window.__VINEXT_LOCALES__ = ${JSON.stringify(locales)};
-registerNavigationRuntimeBootstrap({
-    routeManifest: ${buildRouteManifestExpression(routeManifest)}
-});
 import ${JSON.stringify(entryPath)};`;
 }
 /**
@@ -45,13 +44,17 @@ function isLinkPrefetchRoute(route) {
 	if (route.pagePath !== null) return true;
 	return route.routePath === null && route.layouts.length > 0;
 }
-function toDocumentOnlyAppRoute(route) {
-	return {
+/**
+* App route handlers for hybrid App/Pages ownership, with their static
+* segments hashed so the client never receives their paths in plain text.
+*/
+function toHashedRouteHandlerRoutes(routes) {
+	return routes.flatMap((route) => isLinkPrefetchRoute(route) ? [] : [{
 		canPrefetchLoadingShell: false,
 		documentOnly: true,
-		patternParts: [...route.patternParts],
-		isDynamic: route.isDynamic
-	};
+		isDynamic: route.isDynamic,
+		patternParts: hashRoutePatternParts(route.patternParts)
+	}]);
 }
 function requiresDynamicNavigationRequest(route) {
 	return route.isDynamic && route.parallelSlots.length > 0;
@@ -66,44 +69,104 @@ function hasLoadingBoundary(route, hasSiblingInterceptLoading) {
 	return route.loadingPath !== null || (route.loadingPaths?.some((_, index) => (route.loadingTreePositions?.[index] ?? 0) > 0) ?? false) || route.parallelSlots.some((slot) => slot.loadingPath !== null || (slot.loadingPaths?.length ?? 0) > 0 || slot.interceptingRoutes.some((intercept) => interceptTargetsRoute(intercept.targetPattern, route) && (intercept.loadingPaths?.length ?? 0) > 0)) || hasSiblingInterceptLoading;
 }
 /** Project an `AppRoute` down to the public `VinextLinkPrefetchRoute` shape. */
-function toLinkPrefetchRoute(route, hasSiblingInterceptLoading = route.siblingIntercepts.some((intercept) => interceptTargetsRoute(intercept.targetPattern, route) && (intercept.loadingPaths?.length ?? 0) > 0)) {
+function toLinkPrefetchRoute(route, hasSiblingInterceptLoading = route.siblingIntercepts.some((intercept) => interceptTargetsRoute(intercept.targetPattern, route) && (intercept.loadingPaths?.length ?? 0) > 0), rendersDynamically = false) {
 	return {
 		canPrefetchLoadingShell: hasLoadingBoundary(route, hasSiblingInterceptLoading),
 		patternParts: [...route.patternParts],
 		isDynamic: route.isDynamic,
+		...rendersDynamically ? { rendersDynamically: true } : {},
 		...requiresDynamicNavigationRequest(route) ? { requiresDynamicNavigationRequest: true } : {},
 		...(route.rootParamNames?.length ?? 0) > 0 ? { hasRootParams: true } : {}
 	};
 }
-/** Project App routes together so sibling-intercept loading is applied to its target route. */
-function toLinkPrefetchRoutes(routes) {
+/**
+* Project App routes together so sibling-intercept loading is applied to its
+* target route. `classifier` reads each route's segment config, and each
+* intercepting page's, which applies to its target route.
+*/
+function toLinkPrefetchRoutes(routes, classifier) {
 	const siblingInterceptLoadingTargets = [];
 	for (const route of routes) for (const intercept of route.siblingIntercepts) if ((intercept.loadingPaths?.length ?? 0) > 0) siblingInterceptLoadingTargets.push(splitPatternParts(intercept.targetPattern));
-	return routes.map((route) => isLinkPrefetchRoute(route) ? toLinkPrefetchRoute(route, siblingInterceptLoadingTargets.some((targetParts) => patternsStructurallyEquivalent(targetParts, route.patternParts))) : toDocumentOnlyAppRoute(route));
+	const intercepts = classifier ? collectClassifiedIntercepts(routes, classifier) : [];
+	return routes.filter(isLinkPrefetchRoute).map((route) => {
+		const prefetchRoute = toLinkPrefetchRoute(route, siblingInterceptLoadingTargets.some((targetParts) => patternsStructurallyEquivalent(targetParts, route.patternParts)), classifier?.route(route) ?? false);
+		const routeIntercepts = intercepts.filter(({ targetPatternParts }) => interceptTargetMayMatchRoute(targetPatternParts, route.patternParts)).map(({ intercept }) => intercept);
+		return routeIntercepts.length > 0 ? {
+			...prefetchRoute,
+			intercepts: routeIntercepts
+		} : prefetchRoute;
+	});
 }
-function buildRouteManifestExpression(routeManifest) {
-	if (routeManifest === null) return "null";
-	const graph = routeManifest.segmentGraph;
-	return `{
-  graphVersion: ${JSON.stringify(routeManifest.graphVersion)},
-  segmentGraph: {
-    routes: ${buildMapExpression(graph.routes)},
-    pages: ${buildMapExpression(graph.pages)},
-    routeHandlers: ${buildMapExpression(graph.routeHandlers)},
-    layouts: ${buildMapExpression(graph.layouts)},
-    templates: ${buildMapExpression(graph.templates)},
-    slots: ${buildMapExpression(graph.slots)},
-    defaults: ${buildMapExpression(graph.defaults)},
-    slotBindings: ${buildMapExpression(graph.slotBindings)},
-    interceptions: ${buildMapExpression(graph.interceptions)},
-    interceptionsBySlotId: ${buildMapExpression(graph.interceptionsBySlotId)},
-    boundaries: ${buildMapExpression(graph.boundaries)},
-    rootBoundaries: ${buildMapExpression(graph.rootBoundaries)}
-  }
-}`;
+/**
+* Whether some URL matches both the intercept's target and the route:
+* `/foo/:id` also intercepts a static `/foo/static` route, and `/:name/static`
+* crosses `/foo/:id` at `/foo/static`. A catch-all counts as overlapping; the
+* client checks the URL against the intercept's own target pattern anyway.
+*/
+function interceptTargetMayMatchRoute(targetPatternParts, routePatternParts) {
+	const isParam = (part) => part.startsWith(":");
+	const isCatchAll = (part) => isParam(part) && (part.endsWith("+") || part.endsWith("*"));
+	for (let index = 0;; index++) {
+		const target = targetPatternParts[index];
+		const route = routePatternParts[index];
+		if (target === void 0 || route === void 0) {
+			const rest = target ?? route;
+			return rest === void 0 || isCatchAll(rest) && rest.endsWith("*");
+		}
+		if (isCatchAll(target) || isCatchAll(route)) return true;
+		if (!isParam(target) && !isParam(route) && target !== route) return false;
+	}
+}
+/**
+* Every intercepting page once, with its classification. A slot's intercepts
+* are listed on each route that shares the slot. The intercepted response also
+* renders branches of its source route that the intercepting page's tree
+* doesn't cover, such as other slots, so a source route that renders
+* dynamically makes the intercept dynamic too. The client also counts the
+* descendant route an interception context resolves to.
+*/
+function collectClassifiedIntercepts(routes, classifier) {
+	const sources = /* @__PURE__ */ new Map();
+	const add = (intercept, layoutPaths, route) => {
+		const key = `${intercept.sourceMatchPattern}\0${intercept.pagePath}`;
+		const seen = sources.get(key);
+		if (seen && (seen.route.pattern === intercept.sourceMatchPattern || route.pattern !== intercept.sourceMatchPattern)) return;
+		sources.set(key, {
+			intercept,
+			layoutPaths,
+			route
+		});
+	};
+	for (const route of routes) {
+		for (const slot of route.parallelSlots) {
+			const slotLayoutPaths = slot.layoutPath ? [...route.layouts, slot.layoutPath] : route.layouts;
+			for (const intercept of slot.interceptingRoutes) add(intercept, slotLayoutPaths, route);
+		}
+		for (const intercept of route.siblingIntercepts) add(intercept, route.layouts, route);
+	}
+	return [...sources.values()].map(({ intercept, layoutPaths, route }) => {
+		const rendersDynamically = classifier.intercept(intercept, [...layoutPaths, ...intercept.layoutPaths]) || classifier.route(route);
+		const targetPatternParts = splitPatternParts(intercept.targetPattern);
+		return {
+			intercept: {
+				sourcePatternParts: splitPatternParts(intercept.sourceMatchPattern),
+				targetPatternParts,
+				...rendersDynamically ? { rendersDynamically: true } : {}
+			},
+			targetPatternParts
+		};
+	});
 }
-function buildMapExpression(map) {
-	return `new Map(${JSON.stringify(Array.from(map.entries()))})`;
+/**
+* Generate the virtual module that holds the browser RouteManifest.
+*
+* The App browser runtime imports it dynamically when hydration starts, so the
+* manifest, which grows with every route, stays out of the entry chunk. The
+* JSON string keeps the parse on V8's fast JSON path.
+*/
+function generateBrowserRouteManifestModule(routeManifest) {
+	if (routeManifest === null) return "export default null;";
+	return `export default JSON.parse(${JSON.stringify(JSON.stringify(toBrowserRouteManifestWire(routeManifest)))});`;
 }
 //#endregion
-export { generateBrowserEntry, toLinkPrefetchRoute, toLinkPrefetchRoutes };
+export { generateBrowserEntry, generateBrowserRouteManifestModule, toHashedRouteHandlerRoutes, toLinkPrefetchRoute, toLinkPrefetchRoutes };

package/dist/entries/app-rsc-entry.d.ts

@@ -93,6 +93,8 @@ type AppRouterConfig = {
   draftModeSecret?: string;
   /** Server-only token used to authorize build-time prerender endpoints. */
   prerenderSecret?: string;
+  /** next.config `skipProxyUrlNormalize`. */
+  skipProxyUrlNormalize?: boolean;
   /** next.config `skipTrailingSlashRedirect`. */
   skipTrailingSlashRedirect?: boolean;
   /** Dev-only key authenticating the hybrid Pages handler's forwarded middleware context. */
@@ -110,4 +112,5 @@ export declare function generateAppRequestRscEntry(appDir: string, routes: AppRo
 export declare function generateRscEntry(appDir: string, routes: AppRoute[], middlewarePath?: string | null, metadataRoutes?: MetadataFileRoute[], globalErrorPath?: string | null, basePath?: string, trailingSlash?: boolean, config?: AppRouterConfig, instrumentationPath?: string | null, responseStageOnly?: boolean): string;
 /** Generate the response-only App RSC graph used by the named cache stage. */
 export declare function generateAppResponseRscEntry(appDir: string, routes: AppRoute[], _middlewarePath?: string | null, metadataRoutes?: MetadataFileRoute[], globalErrorPath?: string | null, basePath?: string, trailingSlash?: boolean, config?: AppRouterConfig, instrumentationPath?: string | null): string;
-//#endregion
+//#endregion
+export {};