vinext 1.3.0 → 1.3.1

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

@@ -13,16 +13,30 @@ export declare function generateBrowserEntry(routes?: readonly AppRoute[], pages
   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[];
+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.
  *
@@ -31,4 +45,5 @@ export declare function toLinkPrefetchRoutes(routes: readonly AppRoute[]): Vinex
  * JSON string keeps the parse on V8's fast JSON path.
  */
 export declare function generateBrowserRouteManifestModule(routeManifest: RouteManifest | null): string;
-//#endregion
+//#endregion
+export {};

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

@@ -15,10 +15,10 @@ function generateBrowserEntry(routes = [], pagesPrefetchRoutes = [], rewrites =
 	afterFiles: [],
 	beforeFiles: [],
 	fallback: []
-}, locales = []) {
+}, locales = [], classifier) {
 	const entryPath = resolveRuntimeEntryModule("app-browser-entry");
 	const reactInstanceBootstrapPath = resolveClientRuntimeModule("react-instance-bootstrap");
-	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)};
@@ -69,20 +69,93 @@ 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.filter(isLinkPrefetchRoute).map((route) => toLinkPrefetchRoute(route, siblingInterceptLoadingTargets.some((targetParts) => patternsStructurallyEquivalent(targetParts, route.patternParts))));
+	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;
+	});
+}
+/**
+* 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
+		};
+	});
 }
 /**
 * Generate the virtual module that holds the browser RouteManifest.

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

@@ -112,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 {};

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

@@ -6,8 +6,8 @@ import { extractExportConstString, getAppRouteRenderEntryPath } from "../build/r
 import { routePatternParts } from "../routing/route-pattern.js";
 import { safeJsonStringify } from "../server/html.js";
 import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES } from "../server/image-optimization.js";
-import { buildAppRscManifestCode } from "./app-rsc-manifest.js";
 import { classifyAppPageRouteStaticEligibility } from "../build/app-page-static-eligibility.js";
+import { buildAppRscManifestCode } from "./app-rsc-manifest.js";
 import { generateDevOriginCheckCode } from "../server/dev-origin-check.js";
 import { ACTION_OWNER_MANIFEST_ID } from "../plugins/action-owner-manifest.js";
 import fs from "node:fs";
@@ -46,7 +46,8 @@ const appPageRequestPath = resolveEntryPath("../server/app-page-request.js", imp
 const appSegmentConfigPath = resolveEntryPath("../server/app-segment-config.js", import.meta.url);
 const appRscRouteMatchingPath = resolveEntryPath("../server/app-rsc-route-matching.js", import.meta.url);
 const appRscResponseStagePath = resolveEntryPath("../server/app-rsc-response-stage.js", import.meta.url);
-const rscStreamHintsPath = resolveEntryPath("../server/rsc-stream-hints.js", import.meta.url);
+const rscRenderStreamPath = resolveEntryPath("../server/rsc-render-stream.js", import.meta.url);
+const appClientReferenceManifestPath = resolveEntryPath("../server/app-client-reference-manifest.js", import.meta.url);
 const isrCachePath = resolveEntryPath("../server/isr-cache.js", import.meta.url);
 const thenableParamsShimPath = resolveEntryPath("../shims/thenable-params.js", import.meta.url);
 const appPageElementBuilderPath = resolveEntryPath("../server/app-page-element-builder.js", import.meta.url);
@@ -157,10 +158,18 @@ function buildAppRequestRouteMetadata(routes) {
 				interceptBranchSegments: intercept.branchSegments ?? [],
 				interceptLoadings: [],
 				interceptLoadingTreePositions: intercept.loadingTreePositions ?? [],
+				interceptNotFounds: [],
+				interceptNotFoundTreePositions: intercept.notFoundTreePositions ?? [],
 				interceptNotFoundBranchSegments: intercept.notFoundBranchSegments ?? intercept.branchSegments ?? [],
 				page: null,
 				notFound: null,
 				notFoundTreePosition: intercept.notFoundTreePosition ?? null,
+				interceptForbiddens: [],
+				interceptForbiddenTreePositions: intercept.forbiddenTreePositions ?? [],
+				interceptUnauthorizeds: [],
+				interceptUnauthorizedTreePositions: intercept.unauthorizedTreePositions ?? [],
+				interceptErrors: [],
+				interceptErrorTreePositions: intercept.errorTreePositions ?? [],
 				params: intercept.params
 			}))
 		}])),
@@ -175,10 +184,18 @@ function buildAppRequestRouteMetadata(routes) {
 			interceptBranchSegments: intercept.branchSegments ?? [],
 			interceptLoadings: [],
 			interceptLoadingTreePositions: intercept.loadingTreePositions ?? [],
+			interceptNotFounds: [],
+			interceptNotFoundTreePositions: intercept.notFoundTreePositions ?? [],
 			interceptNotFoundBranchSegments: intercept.notFoundBranchSegments ?? intercept.branchSegments ?? [],
 			page: null,
 			notFound: null,
 			notFoundTreePosition: intercept.notFoundTreePosition ?? null,
+			interceptForbiddens: [],
+			interceptForbiddenTreePositions: intercept.forbiddenTreePositions ?? [],
+			interceptUnauthorizeds: [],
+			interceptUnauthorizedTreePositions: intercept.unauthorizedTreePositions ?? [],
+			interceptErrors: [],
+			interceptErrorTreePositions: intercept.errorTreePositions ?? [],
 			params: intercept.params
 		}))
 	}));
@@ -515,16 +532,13 @@ import ${JSON.stringify(appRouteRequestBuiltInsPath)};` : ""}
 import ${JSON.stringify(serverGlobalsPath)};
 import __cacheabilityManifest from "virtual:vinext-cacheability-manifest";
 export { __cacheabilityManifest };
-import {
-  renderToReadableStream as _renderToReadableStream,
-  ${hasServerActions ? `loadServerAction,
-  createTemporaryReferenceSet,` : ""}
-} from ${JSON.stringify(hasServerActions ? "@vitejs/plugin-rsc/rsc" : "@vitejs/plugin-rsc/react/rsc")};
-import {
+${hasServerActions ? `import { loadServerAction, createTemporaryReferenceSet } from "@vitejs/plugin-rsc/rsc";\n` : ""}import {
   createClientManifest as _createClientManifest,${hasServerActions ? `
   createServerManifest as _createServerManifest,` : ""}
 } from "@vitejs/plugin-rsc/core/rsc";
+import { renderToReadableStream as _renderToReadableStream } from "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge";
 import { prerender as _prerender } from "@vitejs/plugin-rsc/vendor/react-server-dom/static.edge";
+import { createClientReferenceChunksManifest } from ${JSON.stringify(appClientReferenceManifestPath)};
 ${hasServerActions ? `// plugin-rsc's decoders fix an unscoped server manifest; React's own take the
 // manifest, so actions can scope the server references they decode per route.
 import {
@@ -532,12 +546,18 @@ import {
   decodeFormState as _decodeFormState,
   decodeReply as _decodeReply,
 } from "@vitejs/plugin-rsc/vendor/react-server-dom/server.edge";
-` : ""}import { createRscPrerenderer, createRscRenderer } from ${JSON.stringify(rscStreamHintsPath)};
+` : ""}import { createRscRenderer } from ${JSON.stringify(rscRenderStreamPath)};
 
-const renderToReadableStream = createRscRenderer(_renderToReadableStream);
-const prerenderToReadableStream = createRscPrerenderer(async (model, options) =>
-  _prerender(model, _createClientManifest(), options),
+// Each render takes a fresh client manifest: in development, its references
+// carry a new cache tag.
+const __withClientReferenceChunks = createClientReferenceChunksManifest(
+  __pagesClientAssets.appClientReferenceChunks,
+);
+const renderToReadableStream = createRscRenderer((model, options) =>
+  _renderToReadableStream(model, __withClientReferenceChunks(_createClientManifest()), options),
 );
+const prerenderToReadableStream = (model, options) =>
+  _prerender(model, __withClientReferenceChunks(_createClientManifest()), options);
 import { createElement } from "react";
 import { getNavigationContext as _getNavigationContext } from "next/navigation";
 import { configureMemoryCacheHandler as __configureMemoryCacheHandler } from "vinext/shims/cache-handler";
@@ -1133,9 +1153,11 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
           observeMetadataSearchParamsAccess: buildOptions?.observeMetadataSearchParamsAccess === true,
           observePageSearchParamsAccess: buildOptions?.observePageSearchParamsAccess === true,
           isForceStatic: buildOptions?.isForceStatic === true,
+          isUncacheableRender: buildOptions?.isUncacheableRender === true,
           serveStreamingMetadata: buildOptions?.serveStreamingMetadata,
           placeStreamedMetadataInHead: buildOptions?.placeStreamedMetadataInHead === true,
           isProduction: process.env.NODE_ENV === "production",
+          onHeadPrepared: buildOptions?.onHeadPrepared,
         }, layoutParamAccess, displayPathname, scriptNonce);
       },
       clientReuseManifest,
@@ -1590,6 +1612,14 @@ ${responseStageOnly ? "const __responseStageOptions = {" : "const __appRscHandle
           interceptNotFoundBranchSegments: intercept.interceptNotFoundBranchSegments,
           interceptNotFound: intercept.notFound,
           interceptNotFoundTreePosition: intercept.notFoundTreePosition,
+          interceptForbiddens: intercept.interceptForbiddens,
+          interceptForbiddenTreePositions: intercept.interceptForbiddenTreePositions,
+          interceptUnauthorizeds: intercept.interceptUnauthorizeds,
+          interceptUnauthorizedTreePositions: intercept.interceptUnauthorizedTreePositions,
+          interceptErrors: intercept.interceptErrors,
+          interceptErrorTreePositions: intercept.interceptErrorTreePositions,
+          interceptNotFounds: intercept.interceptNotFounds,
+          interceptNotFoundTreePositions: intercept.interceptNotFoundTreePositions,
           interceptSlotId: intercept.slotId,
           interceptSlotKey: intercept.slotKey,
           interceptSourceMatchedUrl: interceptionContext,

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

@@ -60,4 +60,5 @@ export declare function rootBoundaryFiles(routes: readonly AppRoute[]): string[]
  */
 export declare function rootBoundaryRouteFiles(routes: readonly AppRoute[]): string[];
 export declare function buildAppRscManifestCode(options: BuildAppRscManifestCodeOptions): AppRscManifestCode;
-//#endregion
+//#endregion
+export {};

package/dist/entries/app-rsc-manifest.js

@@ -95,6 +95,11 @@ function registerRouteModules(routes, imports) {
 		if (route.unauthorizedPaths) {
 			for (const up of route.unauthorizedPaths) if (up) imports.getLazyLoaderVar(up);
 		}
+		for (const boundaryPath of [
+			...route.segmentNotFoundPaths ?? [],
+			...route.segmentForbiddenPaths ?? [],
+			...route.segmentUnauthorizedPaths ?? []
+		]) imports.getLazyLoaderVar(boundaryPath);
 		for (const slot of route.parallelSlots) {
 			if (slot.pagePath) imports.getLazyLoaderVar(slot.pagePath);
 			if (slot.defaultPath) imports.getLazyLoaderVar(slot.defaultPath);
@@ -104,9 +109,14 @@ function registerRouteModules(routes, imports) {
 			for (const loadingPath of slot.loadingPaths ?? []) imports.getLazyLoaderVar(loadingPath);
 			if (slot.errorPath) imports.getLazyLoaderVar(slot.errorPath);
 			if (slot.notFoundPath) imports.getLazyLoaderVar(slot.notFoundPath);
+			for (const notFoundPath of slot.notFoundPaths ?? []) imports.getLazyLoaderVar(notFoundPath);
 			for (const ir of slot.interceptingRoutes) {
 				imports.getLazyLoaderVar(ir.pagePath);
 				if (ir.notFoundPath) imports.getLazyLoaderVar(ir.notFoundPath);
+				for (const forbiddenPath of ir.forbiddenPaths ?? []) imports.getLazyLoaderVar(forbiddenPath);
+				for (const unauthorizedPath of ir.unauthorizedPaths ?? []) imports.getLazyLoaderVar(unauthorizedPath);
+				for (const errorPath of ir.errorPaths ?? []) imports.getLazyLoaderVar(errorPath);
+				for (const notFoundPath of ir.notFoundPaths ?? []) imports.getLazyLoaderVar(notFoundPath);
 				for (const layoutPath of ir.layoutPaths) imports.getLazyLoaderVar(layoutPath);
 				for (const loadingPath of ir.loadingPaths ?? []) imports.getLazyLoaderVar(loadingPath);
 			}
@@ -114,6 +124,10 @@ function registerRouteModules(routes, imports) {
 		for (const ir of route.siblingIntercepts ?? []) {
 			imports.getLazyLoaderVar(ir.pagePath);
 			if (ir.notFoundPath) imports.getLazyLoaderVar(ir.notFoundPath);
+			for (const forbiddenPath of ir.forbiddenPaths ?? []) imports.getLazyLoaderVar(forbiddenPath);
+			for (const unauthorizedPath of ir.unauthorizedPaths ?? []) imports.getLazyLoaderVar(unauthorizedPath);
+			for (const errorPath of ir.errorPaths ?? []) imports.getLazyLoaderVar(errorPath);
+			for (const notFoundPath of ir.notFoundPaths ?? []) imports.getLazyLoaderVar(notFoundPath);
 			for (const layoutPath of ir.layoutPaths) imports.getLazyLoaderVar(layoutPath);
 			for (const loadingPath of ir.loadingPaths ?? []) imports.getLazyLoaderVar(loadingPath);
 		}
@@ -153,11 +167,23 @@ function buildRouteEntries(routes, imports) {
       __loadInterceptLoadings: ${lazyLoaderArray(ir.loadingPaths ?? [], imports)},
       interceptLoadingTreePositions: ${JSON.stringify(ir.loadingTreePositions ?? [])},
       interceptNotFoundBranchSegments: ${JSON.stringify(ir.notFoundBranchSegments ?? ir.branchSegments ?? [])},
+      interceptNotFounds: ${moduleArray(ir.notFoundPaths?.length ?? 0)},
+      __loadInterceptNotFounds: ${lazyLoaderArray(ir.notFoundPaths ?? [], imports)},
+      interceptNotFoundTreePositions: ${JSON.stringify(ir.notFoundTreePositions ?? [])},
       page: null,
       __pageLoader: ${imports.getLazyLoaderVar(ir.pagePath)},
       notFound: null,
       __loadNotFound: ${ir.notFoundPath ? imports.getLazyLoaderVar(ir.notFoundPath) : "null"},
       notFoundTreePosition: ${ir.notFoundTreePosition ?? "null"},
+      interceptForbiddens: ${moduleArray(ir.forbiddenPaths?.length ?? 0)},
+      __loadInterceptForbiddens: ${lazyLoaderArray(ir.forbiddenPaths ?? [], imports)},
+      interceptForbiddenTreePositions: ${JSON.stringify(ir.forbiddenTreePositions ?? [])},
+      interceptUnauthorizeds: ${moduleArray(ir.unauthorizedPaths?.length ?? 0)},
+      __loadInterceptUnauthorizeds: ${lazyLoaderArray(ir.unauthorizedPaths ?? [], imports)},
+      interceptUnauthorizedTreePositions: ${JSON.stringify(ir.unauthorizedTreePositions ?? [])},
+      interceptErrors: ${moduleArray(ir.errorPaths?.length ?? 0)},
+      __loadInterceptErrors: ${lazyLoaderArray(ir.errorPaths ?? [], imports)},
+      interceptErrorTreePositions: ${JSON.stringify(ir.errorTreePositions ?? [])},
       params: ${JSON.stringify(ir.params)},
     }`);
 		const slotEntries = route.parallelSlots.map((slot) => {
@@ -174,11 +200,23 @@ function buildRouteEntries(routes, imports) {
           __loadInterceptLoadings: ${lazyLoaderArray(ir.loadingPaths ?? [], imports)},
           interceptLoadingTreePositions: ${JSON.stringify(ir.loadingTreePositions ?? [])},
           interceptNotFoundBranchSegments: ${JSON.stringify(ir.notFoundBranchSegments ?? ir.branchSegments ?? [])},
+          interceptNotFounds: ${moduleArray(ir.notFoundPaths?.length ?? 0)},
+          __loadInterceptNotFounds: ${lazyLoaderArray(ir.notFoundPaths ?? [], imports)},
+          interceptNotFoundTreePositions: ${JSON.stringify(ir.notFoundTreePositions ?? [])},
           page: null,
           __pageLoader: ${imports.getLazyLoaderVar(ir.pagePath)},
           notFound: null,
           __loadNotFound: ${ir.notFoundPath ? imports.getLazyLoaderVar(ir.notFoundPath) : "null"},
           notFoundTreePosition: ${ir.notFoundTreePosition ?? "null"},
+          interceptForbiddens: ${moduleArray(ir.forbiddenPaths?.length ?? 0)},
+          __loadInterceptForbiddens: ${lazyLoaderArray(ir.forbiddenPaths ?? [], imports)},
+          interceptForbiddenTreePositions: ${JSON.stringify(ir.forbiddenTreePositions ?? [])},
+          interceptUnauthorizeds: ${moduleArray(ir.unauthorizedPaths?.length ?? 0)},
+          __loadInterceptUnauthorizeds: ${lazyLoaderArray(ir.unauthorizedPaths ?? [], imports)},
+          interceptUnauthorizedTreePositions: ${JSON.stringify(ir.unauthorizedTreePositions ?? [])},
+          interceptErrors: ${moduleArray(ir.errorPaths?.length ?? 0)},
+          __loadInterceptErrors: ${lazyLoaderArray(ir.errorPaths ?? [], imports)},
+          interceptErrorTreePositions: ${JSON.stringify(ir.errorTreePositions ?? [])},
           params: ${JSON.stringify(ir.params)},
         }`);
 			return `      ${JSON.stringify(slot.key)}: {
@@ -204,6 +242,9 @@ function buildRouteEntries(routes, imports) {
         notFound: null,
         __loadNotFound: ${slot.notFoundPath ? imports.getLazyLoaderVar(slot.notFoundPath) : "null"},
         notFoundTreePosition: ${slot.notFoundTreePosition ?? "null"},
+        notFounds: ${moduleArray(slot.notFoundPaths?.length ?? 0)},
+        __loadNotFounds: ${lazyLoaderArray(slot.notFoundPaths ?? [], imports)},
+        notFoundTreePositions: ${JSON.stringify(slot.notFoundTreePositions ?? [])},
         layoutIndex: ${slot.layoutIndex},
         routeSegments: ${JSON.stringify(slot.routeSegments)},
         slotPatternParts: ${slot.slotPatternParts ? JSON.stringify(slot.slotPatternParts) : "null"},
@@ -214,6 +255,9 @@ ${interceptEntries.join(",\n")}
       }`;
 		});
 		const layoutErrorPaths = route.layoutErrorPaths ?? [];
+		const segmentNotFoundPaths = route.segmentNotFoundPaths ?? [];
+		const segmentForbiddenPaths = route.segmentForbiddenPaths ?? [];
+		const segmentUnauthorizedPaths = route.segmentUnauthorizedPaths ?? [];
 		const errorPaths = route.errorPaths ?? [];
 		const layoutErrorLoaders = lazyLoaderArray(layoutErrorPaths, imports);
 		const errorLoaders = lazyLoaderArray(errorPaths, imports);
@@ -276,6 +320,15 @@ ${siblingInterceptEntries.join(",\n")}
     unauthorizedTreePosition: ${route.unauthorizedTreePosition ?? "null"},
     unauthorizeds: ${moduleArray(unauthorizedPaths.length)},
     __loadUnauthorizeds: ${unauthorizedLoaders},
+    segmentNotFounds: ${moduleArray(segmentNotFoundPaths.length)},
+    __loadSegmentNotFounds: ${lazyLoaderArray(segmentNotFoundPaths, imports)},
+    segmentNotFoundTreePositions: ${JSON.stringify(route.segmentNotFoundTreePositions ?? [])},
+    segmentForbiddens: ${moduleArray(segmentForbiddenPaths.length)},
+    __loadSegmentForbiddens: ${lazyLoaderArray(segmentForbiddenPaths, imports)},
+    segmentForbiddenTreePositions: ${JSON.stringify(route.segmentForbiddenTreePositions ?? [])},
+    segmentUnauthorizeds: ${moduleArray(segmentUnauthorizedPaths.length)},
+    __loadSegmentUnauthorizeds: ${lazyLoaderArray(segmentUnauthorizedPaths, imports)},
+    segmentUnauthorizedTreePositions: ${JSON.stringify(route.segmentUnauthorizedTreePositions ?? [])},
   }`;
 	});
 }

package/dist/entries/pages-entry-helpers.js

@@ -1,2 +1 @@
-import { findFileWithExts } from "../routing/file-matcher.js";
-export { findFileWithExts };
+export { findFileWithExts } from "../routing/file-matcher.js";

package/dist/entries/pages-server-entry.d.ts

@@ -17,4 +17,5 @@ export declare function generatePagesRequestEntry(pagesDir: string, nextConfig:
  */
 export declare function generatePagesResponseEntry(pagesDir: string, nextConfig: ResolvedNextConfig, fileMatcher: ReturnType<typeof createValidFileMatcher>, middlewarePath: string | null, instrumentationPath: string | null, prerenderSecret?: string): Promise<string>;
 export declare function generateServerEntry(pagesDir: string, nextConfig: ResolvedNextConfig, fileMatcher: ReturnType<typeof createValidFileMatcher>, middlewarePath: string | null, instrumentationPath: string | null, publicFiles?: string[], options?: GeneratePagesServerEntryOptions): Promise<string>;
-//#endregion
+//#endregion
+export {};

package/dist/entries/pages-server-entry.js

@@ -318,7 +318,7 @@ export async function runMiddleware(request, ctx) {
 	return `
 import ${JSON.stringify(_serverGlobalsPath)};
 import React from "react";
-import { renderToReadableStream } from "react-dom/server.edge";
+import { renderToReadableStream } from "react-dom/server";
 import { resetSSRHead, getSSRHeadHTML, setDocumentInitialHead } from "next/head";
 import { flushPreloads } from "next/dynamic";
 import Router, { setSSRContext, wrapWithRouterContext, getPagesNavigationIsReadyFromSerializedState } from "next/router";

package/dist/entries/runtime-entry-module.d.ts

@@ -21,4 +21,5 @@ export declare function resolveEntryPath(rel: string, base: string): string;
  */
 export declare function resolveRuntimeEntryModule(name: string): string;
 export declare function resolveClientRuntimeModule(name: string): string;
+export declare function resolveShimRuntimeModule(name: string): string;
 //#endregion

package/dist/entries/runtime-entry-module.js

@@ -30,6 +30,9 @@ function resolveRuntimeEntryModule(name) {
 function resolveClientRuntimeModule(name) {
 	return resolveRuntimeModulePath("client", name);
 }
+function resolveShimRuntimeModule(name) {
+	return resolveRuntimeModulePath("shims", name);
+}
 function resolveRuntimeModulePath(directory, name) {
 	for (const ext of [
 		".ts",
@@ -43,4 +46,4 @@ function resolveRuntimeModulePath(directory, name) {
 	return resolveEntryPath(`../${directory}/${name}.js`, import.meta.url);
 }
 //#endregion
-export { resolveClientRuntimeModule, resolveEntryPath, resolveRuntimeEntryModule };
+export { resolveClientRuntimeModule, resolveEntryPath, resolveRuntimeEntryModule, resolveShimRuntimeModule };

package/dist/image/image-adapters-virtual.d.ts

@@ -57,4 +57,5 @@ export declare const VIRTUAL_IMAGE_ADAPTERS = "virtual:vinext-image-adapters";
  * given config. Always exports `registerConfiguredImageOptimizer(env)`.
  */
 export declare function generateImageAdaptersModule(images?: VinextImageConfig): string;
-//#endregion
+//#endregion
+export {};