vinext 1.3.0 → 1.3.1

package/dist/server/app-render-dependency.d.ts

@@ -11,7 +11,17 @@ export type AppPageRenderDependency = AppRenderDependency & {
 /** Whether `component` is a "use client" export seen from the RSC environment. */
 export declare function isAppClientReference(component: unknown): boolean;
 export declare function isReactOwnedAppComponent(component: unknown): boolean;
-export declare function invokeAppComponent(component: ComponentType<Record<string, unknown>>, props: Readonly<Record<string, unknown>>): ReactNode | Promise<ReactNode>;
+/**
+ * `mapError` replaces an error thrown by a CSS-wrapped export's inner
+ * component, which renders after this call returns. The caller maps the
+ * errors this call throws or rejects with.
+ */
+export declare function invokeAppComponent(component: ComponentType<Record<string, unknown>>, props: Readonly<Record<string, unknown>>, mapError?: (error: unknown) => unknown): ReactNode | Promise<ReactNode>;
+/**
+ * `invokeAppComponent()`, with every error the component throws or rejects
+ * with replaced by `mapError(error)`, including its CSS-wrapped inner one's.
+ */
+export declare function invokeAppComponentMappingErrors(component: ComponentType<Record<string, unknown>>, props: Readonly<Record<string, unknown>>, mapError: (error: unknown) => unknown): ReactNode | Promise<ReactNode>;
 export declare function registerAppElementRenderDependencies(elements: Readonly<Record<string, unknown>>, dependenciesByElementId: ReadonlyMap<string, AppRenderDependency>): void;
 export declare function releaseAppElementRenderDependency(elements: Readonly<Record<string, unknown>>, elementId: string): void;
 export declare function createAppRenderDependency(): AppRenderDependency;

package/dist/server/app-render-dependency.js

@@ -15,14 +15,33 @@ function isReactOwnedAppComponent(component) {
 	if (candidate?.$$typeof === REACT_MEMO || candidate?.$$typeof === REACT_LAZY || candidate?.$$typeof === REACT_FORWARD_REF) return false;
 	return typeof candidate !== "function" || candidate.$$typeof === REACT_CLIENT_REFERENCE || candidate.prototype?.isReactComponent != null;
 }
-function invokeAppComponent(component, props) {
+/**
+* `mapError` replaces an error thrown by a CSS-wrapped export's inner
+* component, which renders after this call returns. The caller maps the
+* errors this call throws or rejects with.
+*/
+function invokeAppComponent(component, props, mapError) {
 	const candidate = component;
-	if (candidate.$$typeof === REACT_MEMO && candidate.type) return invokeAppComponent(candidate.type, props);
-	if (candidate.$$typeof === REACT_LAZY && candidate._init) return invokeAppComponent(candidate._init(candidate._payload), props);
+	if (candidate.$$typeof === REACT_MEMO && candidate.type) return invokeAppComponent(candidate.type, props, mapError);
+	if (candidate.$$typeof === REACT_LAZY && candidate._init) return invokeAppComponent(candidate._init(candidate._payload), props, mapError);
 	if (candidate.$$typeof === REACT_FORWARD_REF && candidate.render) return candidate.render(props, void 0);
 	if (isReactOwnedAppComponent(candidate)) return createElement(candidate, props);
 	const result = candidate(props);
-	return isPromiseLike(result) ? result : invokeCssWrappedComponent(result, props);
+	return isPromiseLike(result) ? result : invokeCssWrappedComponent(result, props, mapError);
+}
+/**
+* `invokeAppComponent()`, with every error the component throws or rejects
+* with replaced by `mapError(error)`, including its CSS-wrapped inner one's.
+*/
+function invokeAppComponentMappingErrors(component, props, mapError) {
+	try {
+		const result = invokeAppComponent(component, props, mapError);
+		return isPromiseLike(result) ? Promise.resolve(result).catch((error) => {
+			throw mapError(error);
+		}) : result;
+	} catch (error) {
+		throw mapError(error);
+	}
 }
 /**
 * Whether `elementProps` are what `createElement(type, props)` produces: the
@@ -48,7 +67,7 @@ function isElementOfProps(elementProps, props, defaultProps) {
 * component from an element without props instead, as for an export without
 * CSS.
 */
-function invokeCssWrappedComponent(result, props) {
+function invokeCssWrappedComponent(result, props, mapError) {
 	if (!isValidElement(result) || result.type !== Fragment || result.key !== null) return result;
 	const children = result.props.children;
 	if (!Array.isArray(children) || children.length !== 2) return result;
@@ -58,7 +77,7 @@ function invokeCssWrappedComponent(result, props) {
 	if (!isElementOfProps(inner.props, props, component.defaultProps)) return result;
 	const componentProps = inner.props;
 	function CssWrappedComponent() {
-		return invokeAppComponent(component, componentProps);
+		return mapError ? invokeAppComponentMappingErrors(component, componentProps, mapError) : invokeAppComponent(component, componentProps);
 	}
 	CssWrappedComponent.displayName = component.displayName ?? component.name;
 	return createElement(Fragment, null, css, createElement(CssWrappedComponent));
@@ -132,4 +151,4 @@ function renderAppComponentWithDependencyBarrier(component, props, dependency) {
 	return createElement(AppComponentDependencyBarrier);
 }
 //#endregion
-export { createAppPageRenderDependency, createAppRenderDependency, invokeAppComponent, isAppClientReference, isAppRenderSuspension, isReactOwnedAppComponent, registerAppElementRenderDependencies, releaseAppElementRenderDependency, renderAfterAppDependencies, renderAppComponentWithDependencyBarrier };
+export { createAppPageRenderDependency, createAppRenderDependency, invokeAppComponent, invokeAppComponentMappingErrors, isAppClientReference, isAppRenderSuspension, isReactOwnedAppComponent, registerAppElementRenderDependencies, releaseAppElementRenderDependency, renderAfterAppDependencies, renderAppComponentWithDependencyBarrier };

package/dist/server/app-request-stage-independent-entry.d.ts

@@ -5,4 +5,5 @@ import { DispatchAppWorkerResponseStage } from "./app-worker-stages.js";
 export type AppRequestStageEnv = Record<string, unknown>;
 type AppRequestStageContext = ExecutionContextLike & VinextRequestStageContext;
 export declare function handleRequestStage(request: Request, env: AppRequestStageEnv | undefined, ctx: AppRequestStageContext | undefined, dispatchResponseStage: DispatchAppWorkerResponseStage): Promise<Response>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-response-stage-entry.d.ts

@@ -6,4 +6,5 @@ type AppResponseStageEnv = Record<string, unknown>;
 /** Invoke one transformed public cache function without rendering its owning route. */
 export declare function invokeCacheFunction(invocation: VinextCacheFunctionInvocation, env: AppResponseStageEnv | undefined, platformCtx: ExecutionContextLike | undefined, dispatchRequestStage: VinextRequestStageTransport): Promise<void>;
 export declare function handleResponseStage(request: Request, env: AppResponseStageEnv | undefined, platformCtx: ExecutionContextLike | undefined, props: AppWorkerResponseStageProps, dispatchRequestStage: VinextRequestStageTransport, options?: VinextResponseStageDispatchOptions): Promise<Response>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-route-handler-cache.d.ts

@@ -45,4 +45,5 @@ type ReadAppRouteHandlerCacheOptions = {
   } | null) => void;
 };
 export declare function readAppRouteHandlerCacheResponse(options: ReadAppRouteHandlerCacheOptions): Promise<Response | null>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-route-handler-dispatch.d.ts

@@ -46,4 +46,5 @@ type DispatchAppRouteHandlerOptions = {
   searchParams: URLSearchParams;
 };
 export declare function dispatchAppRouteHandler(options: DispatchAppRouteHandlerOptions): Promise<Response>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-route-handler-dispatch.js

@@ -14,9 +14,9 @@ import { resolveAppRouteHandlerFetchCacheMode } from "./app-segment-config.js";
 import { setNavigationContext } from "../shims/navigation-context-state.js";
 import { makeThenableParams } from "../shims/thenable-params.js";
 import { traceResponseStart } from "./response-start-tracing.js";
-import { buildPageCacheTags } from "./implicit-tags.js";
 import { applyRouteHandlerMiddlewareContext, finalizeRouteHandlerResponse } from "./app-route-handler-response.js";
 import "../shims/navigation.js";
+import { buildPageCacheTags } from "./implicit-tags.js";
 import { isKnownDynamicAppRoute, isValidHTTPMethod } from "./app-route-handler-runtime.js";
 import { getAppRouteHandlerRevalidateSeconds, hasAppRouteHandlerDefaultExport, hasNonStaticAppRouteHandlerMethods, resolveAppRouteHandlerMethod, shouldReadAppRouteHandlerCache } from "./app-route-handler-policy.js";
 import { createStaticGenerationHeadersContext } from "./app-static-generation.js";

package/dist/server/app-route-handler-execution.d.ts

@@ -104,4 +104,5 @@ type ExecuteAppRouteHandlerOptions = {
 export declare function runAppRouteHandler(options: RunAppRouteHandlerOptions): Promise<RunAppRouteHandlerResult>;
 export declare function executeAppRouteHandler(options: ExecuteAppRouteHandlerOptions): Promise<Response>;
 export declare function traceAppRouteHandlerExecution<T>(routePattern: string, callback: (span: FrameworkSpan) => T): T;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-route-handler-response.d.ts

@@ -26,4 +26,5 @@ export declare function applyRouteHandlerRevalidateHeader(response: Response, re
 export declare function markRouteHandlerCacheMiss(response: Response): void;
 export declare function buildAppRouteCacheValue(response: Response, browserCacheControl?: string): Promise<CachedRouteValue>;
 export declare function finalizeRouteHandlerResponse(response: Response, options: FinalizeRouteHandlerResponseOptions): Response;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-route-handler-runtime.d.ts

@@ -39,4 +39,5 @@ type TrackedAppRouteRequest = {
   didAccessDynamicRequest(): boolean;
 };
 export declare function createTrackedAppRouteRequest(request: Request, options?: TrackedAppRouteRequestOptions): TrackedAppRouteRequest;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-route-module-loader.d.ts

@@ -43,6 +43,14 @@ type LazyLoadableIntercept = {
   __loadInterceptLayouts?: LazyModuleLoaderArray | null;
   interceptLoadings?: readonly unknown[] | null;
   __loadInterceptLoadings?: LazyModuleLoaderArray | null;
+  interceptNotFounds?: readonly unknown[] | null;
+  __loadInterceptNotFounds?: LazyModuleLoaderArray | null;
+  interceptForbiddens?: readonly unknown[] | null;
+  __loadInterceptForbiddens?: LazyModuleLoaderArray | null;
+  interceptUnauthorizeds?: readonly unknown[] | null;
+  __loadInterceptUnauthorizeds?: LazyModuleLoaderArray | null;
+  interceptErrors?: readonly unknown[] | null;
+  __loadInterceptErrors?: LazyModuleLoaderArray | null;
   __loadState?: {
     page?: unknown;
     pageLoading?: Promise<unknown> | null;
@@ -60,6 +68,7 @@ type LazyLoadableSlot = {
   loadings?: readonly unknown[];
   error?: unknown;
   notFound?: unknown;
+  notFounds?: readonly unknown[];
   __loadPage?: LazyModuleThunk | null;
   __loadDefault?: LazyModuleThunk | null;
   __loadLayout?: LazyModuleThunk | null;
@@ -68,6 +77,7 @@ type LazyLoadableSlot = {
   __loadLoadings?: LazyModuleLoaderArray | null;
   __loadError?: LazyModuleThunk | null;
   __loadNotFound?: LazyModuleThunk | null;
+  __loadNotFounds?: LazyModuleLoaderArray | null;
   /** Hydrated only after an intercept matches, not with the slot's base modules. */
   intercepts?: LazyLoadableIntercept[];
 };
@@ -82,6 +92,9 @@ export type LazyLoadableRoute = {
   notFounds?: unknown[];
   forbiddens?: unknown[];
   unauthorizeds?: unknown[];
+  segmentNotFounds?: unknown[];
+  segmentForbiddens?: unknown[];
+  segmentUnauthorizeds?: unknown[];
   loading?: unknown;
   error?: unknown;
   notFound?: unknown;
@@ -101,6 +114,9 @@ export type LazyLoadableRoute = {
   __loadNotFounds?: LazyModuleLoaderArray | null;
   __loadForbiddens?: LazyModuleLoaderArray | null;
   __loadUnauthorizeds?: LazyModuleLoaderArray | null;
+  __loadSegmentNotFounds?: LazyModuleLoaderArray | null;
+  __loadSegmentForbiddens?: LazyModuleLoaderArray | null;
+  __loadSegmentUnauthorizeds?: LazyModuleLoaderArray | null;
   __loadLoading?: LazyModuleThunk | null;
   __loadError?: LazyModuleThunk | null;
   __loadNotFound?: LazyModuleThunk | null;
@@ -123,4 +139,5 @@ export declare function loadAppInterceptLayouts(intercept: LazyLoadableIntercept
  * `null`/`undefined` routes and on eager routes that have no lazy thunks.
  */
 export declare function ensureAppRouteModulesLoaded<TRoute extends LazyLoadableRoute>(route: TRoute | null | undefined): TRoute | Promise<TRoute>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-route-module-loader.js

@@ -92,6 +92,10 @@ function loadAppInterceptLayouts(intercept) {
 	const loads = [];
 	pushArrayLoads(loads, intercept.interceptLayouts, intercept.__loadInterceptLayouts);
 	pushArrayLoads(loads, intercept.interceptLoadings, intercept.__loadInterceptLoadings);
+	pushArrayLoads(loads, intercept.interceptNotFounds, intercept.__loadInterceptNotFounds);
+	pushArrayLoads(loads, intercept.interceptForbiddens, intercept.__loadInterceptForbiddens);
+	pushArrayLoads(loads, intercept.interceptUnauthorizeds, intercept.__loadInterceptUnauthorizeds);
+	pushArrayLoads(loads, intercept.interceptErrors, intercept.__loadInterceptErrors);
 	if (loads.length === 0) return Promise.resolve(intercept.interceptLayouts ?? []);
 	const loading = shareIsolatePromise(Promise.all(loads).then(() => {
 		if (loadState) loadState.interceptLayoutsLoading = null;
@@ -130,6 +134,9 @@ function ensureAppRouteModulesLoaded(route) {
 	pushArrayLoads(loads, route.notFounds, route.__loadNotFounds);
 	pushArrayLoads(loads, route.forbiddens, route.__loadForbiddens);
 	pushArrayLoads(loads, route.unauthorizeds, route.__loadUnauthorizeds);
+	pushArrayLoads(loads, route.segmentNotFounds, route.__loadSegmentNotFounds);
+	pushArrayLoads(loads, route.segmentForbiddens, route.__loadSegmentForbiddens);
+	pushArrayLoads(loads, route.segmentUnauthorizeds, route.__loadSegmentUnauthorizeds);
 	for (const slot of Object.values(route.slots ?? {})) {
 		pushFieldLoad(loads, slot, "page", slot.__loadPage);
 		pushFieldLoad(loads, slot, "default", slot.__loadDefault);
@@ -139,6 +146,7 @@ function ensureAppRouteModulesLoaded(route) {
 		pushArrayLoads(loads, slot.loadings, slot.__loadLoadings);
 		pushFieldLoad(loads, slot, "error", slot.__loadError);
 		pushFieldLoad(loads, slot, "notFound", slot.__loadNotFound);
+		pushArrayLoads(loads, slot.notFounds, slot.__loadNotFounds);
 	}
 	if (loads.length === 0) {
 		route.__loaded = true;

package/dist/server/app-route-tree-prefetch.d.ts

@@ -39,4 +39,5 @@ export type PrefetchInliningConfig = false | {
 };
 export declare function isRouteTreePrefetchRequest(request: Request): boolean;
 export declare function createRouteTreePrefetchResponse(route: AppRouteTreePrefetchRoute, options?: RouteTreePrefetchResponseOptions): Promise<Response>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-rsc-error-handler.d.ts

@@ -23,4 +23,5 @@ export type AppRenderErrorContextOverrides = {
  * Pure factory: takes all deps explicitly — no closure over module-level state.
  */
 export declare function createAppRscOnErrorHandler(reportRequestError: ReportRequestError, request: Request, pathname: string, routePath: string, overrides?: AppRenderErrorContextOverrides): (error: unknown) => string | undefined;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-rsc-errors.d.ts

@@ -46,4 +46,5 @@ export declare function errorDigest(input: string): string;
 export declare const PRODUCTION_SERVER_COMPONENTS_ERROR_MESSAGE = "Minified React error #441; visit https://react.dev/errors/441 for the full message or use the non-minified dev environment for full errors and additional helpful warnings.";
 export declare function sanitizeErrorForClient(error: unknown, nodeEnv?: "development" | "production" | "test"): unknown;
 export declare function createRscOnErrorHandler(options: CreateRscOnErrorHandlerOptions): (error: unknown) => string | undefined;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-rsc-handler.d.ts

@@ -263,4 +263,5 @@ export type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
 export type AppRscRequestHandler = (request: Request, ctx: unknown, allowInternalRscDocumentFallback?: boolean, dispatchResponseStage?: DispatchAppWorkerResponseStage, responseStageProbeMode?: VinextCacheabilityProbeMode | null, trustedPrerenderState?: TrustedPrerenderState | null) => Promise<Response>;
 /** Build the request-only handler without retaining the response renderer graph. */
 export declare function createAppRscRequestHandler<TRoute extends AppRscHandlerRoute>(options: CreateAppRscHandlerOptions<TRoute>): AppRscRequestHandler;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-rsc-handler.js

@@ -37,11 +37,11 @@ import { traceAppPageRender } from "./app-page-tracing.js";
 import { openForwardedMiddlewareContext } from "./forwarded-middleware-context.js";
 import { setFrameworkRequestRoute, traceFrameworkRequest } from "./request-tracing.js";
 import { matchPrerenderRouteParamsPayload, readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
-import { buildPageCacheTags } from "./implicit-tags.js";
 import { createServerActionNotFoundResponse, getServerActionNotFoundMessage } from "./server-action-not-found.js";
 import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
 import { isAppRouteHandlerRoute } from "./app-rsc-route-matching.js";
 import { normalizeInterceptionContextHeader } from "./app-interception-context-header.js";
+import { buildPageCacheTags } from "./implicit-tags.js";
 import { buildPostMwRequestContext } from "./app-post-middleware-context.js";
 import { pickRootParams, setRootParams } from "../shims/root-params.js";
 import { createRouteTreePrefetchResponse, isRouteTreePrefetchRequest } from "./app-route-tree-prefetch.js";
@@ -195,10 +195,6 @@ function createMissingServerActionResponse(options, actionId) {
 	options.clearRequestContext();
 	return createServerActionNotFoundResponse();
 }
-function redirectDestinationWithBasePath(destination, basePath, hadBasePath) {
-	if (!basePath || !hadBasePath || isExternalUrl(destination) || hasBasePath(destination, basePath)) return destination;
-	return basePath + destination;
-}
 async function applyRewrite(options, cleanPathname, recordCacheability = true) {
 	if (!HAS_CONFIG_REWRITES || !options.rewrites.length) return null;
 	const sourcePathname = options.paramsPathname ?? cleanPathname;
@@ -371,7 +367,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		});
 		if (prerenderEndpointResponse) return prerenderEndpointResponse;
 	}
-	if (!options.skipTrailingSlashRedirect) {
+	if (!isDataRequest && !options.skipTrailingSlashRedirect) {
 		const trailingSlashRedirect = options.trailingSlash && options.isMetadataRoutePath && await options.isMetadataRoutePath(cleanPathname) ? null : normalizeTrailingSlash(requestCleanPathname, hadBasePath ? options.basePath : "", options.trailingSlash, url.search);
 		if (trailingSlashRedirect) return trailingSlashRedirect;
 	}
@@ -385,10 +381,10 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 	const configMatchers = HAS_CONFIG_REDIRECTS && options.configRedirects.length ? await import("../config/config-matchers.js") : null;
 	const redirect = configMatchers ? configMatchers.matchRedirect(redirectPathname, options.configRedirects, preMiddlewareRequestContext, basePathState, dispatchResponseStage ? void 0 : markConditionalRedirectCacheability) : null;
 	if (configMatchers && redirect) {
-		const destination = configMatchers.sanitizeDestination(redirectDestinationWithBasePath(redirect.destination, options.basePath, hadBasePath));
-		const location = isRscRequest && request.headers.get("RSC") === "1" ? await createRscRedirectLocation(destination, request) : configMatchers.preserveRedirectDestinationQuery(destination, url.search, redirect.destinationQuery);
+		const destination = redirect.destination;
+		const location = isRscRequest && request.headers.get("RSC") === "1" ? await createRscRedirectLocation(configMatchers.encodeRedirectLocation(destination), request) : configMatchers.encodeRedirectLocation(configMatchers.preserveRedirectDestinationQuery(destination, url.search, redirect.destinationQuery));
 		return new Response(null, {
-			status: redirect.permanent ? 308 : 307,
+			status: redirect.statusCode,
 			headers: { Location: location }
 		});
 	}
@@ -484,7 +480,7 @@ async function handleAppRscRequest(options, request, preMiddlewareRequestContext
 		const cache = responseStageProbeMode || isOnDemandRevalidate || (props.kind === "app-page" || props.kind === "app-route-handler") && (props.bypassInterceptionContextCache || props.forceDynamic === true && responseStagePolicy === null) ? "bypass" : canUseSharedWorkerResponseStage ? "shared" : "bypass";
 		let dispatchRequest = props.kind === "app-page" ? prepareSharedAppPageDispatch(stageRequest, cache) : stageRequest;
 		let canonicalRsc = null;
-		if (cache === "shared" && props.kind === "app-page" && props.isRscRequest && props.matchKind === "request" && props.interceptionContext === null && props.interceptionId === null && props.mountedSlotsHeader === null) {
+		if (cache === "shared" && props.kind === "app-page" && props.isRscRequest && (props.matchKind === "request" || props.matchKind === "resolved") && props.interceptionContext === null && props.interceptionId === null && props.mountedSlotsHeader === null) {
 			const headers = new Headers(dispatchRequest.headers);
 			if (props.renderMode === "navigation" ? canonicalizePrewarmableRscRequestHeaders(headers) : props.renderMode === "prefetch-loading-shell" && props.canUseCanonicalLoadingShell ? canonicalizeLoadingShellRscRequestHeaders(headers) : false) {
 				canonicalRsc = {

package/dist/server/app-rsc-response-finalizer.d.ts

@@ -47,4 +47,5 @@ export declare function applyAppRscConfigHeaders(headers: Headers, request: Requ
  * to redirects regardless.
  */
 export declare function finalizeAppRscResponse(response: Response, request: Request, options: FinalizeAppRscResponseOptions): Promise<Response>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-rsc-route-matching.d.ts

@@ -35,13 +35,25 @@ type AppRscInterceptForMatching = {
   interceptLoadings?: readonly unknown[];
   interceptLoadingTreePositions?: readonly number[];
   interceptNotFoundBranchSegments?: readonly string[];
+  interceptNotFounds?: readonly unknown[];
+  interceptNotFoundTreePositions?: readonly number[];
   __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
   __loadInterceptLoadings?: readonly (() => Promise<unknown>)[] | null;
+  __loadInterceptNotFounds?: readonly (() => Promise<unknown>)[] | null;
   page: unknown;
   __pageLoader?: (() => Promise<unknown>) | null;
   notFound?: unknown;
   __loadNotFound?: (() => Promise<unknown>) | null;
   notFoundTreePosition?: number | null;
+  interceptForbiddens?: readonly unknown[];
+  interceptForbiddenTreePositions?: readonly number[];
+  __loadInterceptForbiddens?: readonly (() => Promise<unknown>)[] | null;
+  interceptUnauthorizeds?: readonly unknown[];
+  interceptUnauthorizedTreePositions?: readonly number[];
+  __loadInterceptUnauthorizeds?: readonly (() => Promise<unknown>)[] | null;
+  interceptErrors?: readonly unknown[];
+  interceptErrorTreePositions?: readonly number[];
+  __loadInterceptErrors?: readonly (() => Promise<unknown>)[] | null;
   params: readonly string[];
 };
 type AppRscSlotForMatching = {
@@ -60,13 +72,25 @@ type AppRscSiblingInterceptForMatching = {
   interceptLoadings?: readonly unknown[];
   interceptLoadingTreePositions?: readonly number[];
   interceptNotFoundBranchSegments?: readonly string[];
+  interceptNotFounds?: readonly unknown[];
+  interceptNotFoundTreePositions?: readonly number[];
   __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
   __loadInterceptLoadings?: readonly (() => Promise<unknown>)[] | null;
+  __loadInterceptNotFounds?: readonly (() => Promise<unknown>)[] | null;
   page: unknown;
   __pageLoader?: (() => Promise<unknown>) | null;
   notFound?: unknown;
   __loadNotFound?: (() => Promise<unknown>) | null;
   notFoundTreePosition?: number | null;
+  interceptForbiddens?: readonly unknown[];
+  interceptForbiddenTreePositions?: readonly number[];
+  __loadInterceptForbiddens?: readonly (() => Promise<unknown>)[] | null;
+  interceptUnauthorizeds?: readonly unknown[];
+  interceptUnauthorizedTreePositions?: readonly number[];
+  __loadInterceptUnauthorizeds?: readonly (() => Promise<unknown>)[] | null;
+  interceptErrors?: readonly unknown[];
+  interceptErrorTreePositions?: readonly number[];
+  __loadInterceptErrors?: readonly (() => Promise<unknown>)[] | null;
   params: readonly string[];
 };
 type AppRscRouteForMatching = {
@@ -108,13 +132,25 @@ type AppRscInterceptLookupEntry = {
   interceptLoadings?: readonly unknown[];
   interceptLoadingTreePositions?: readonly number[];
   interceptNotFoundBranchSegments?: readonly string[];
+  interceptNotFounds?: readonly unknown[];
+  interceptNotFoundTreePositions?: readonly number[];
   __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
   __loadInterceptLoadings?: readonly (() => Promise<unknown>)[] | null;
+  __loadInterceptNotFounds?: readonly (() => Promise<unknown>)[] | null;
   page: unknown;
   __pageLoader?: (() => Promise<unknown>) | null;
   notFound: unknown;
   __loadNotFound?: (() => Promise<unknown>) | null;
   notFoundTreePosition?: number | null;
+  interceptForbiddens?: readonly unknown[];
+  interceptForbiddenTreePositions?: readonly number[];
+  __loadInterceptForbiddens?: readonly (() => Promise<unknown>)[] | null;
+  interceptUnauthorizeds?: readonly unknown[];
+  interceptUnauthorizedTreePositions?: readonly number[];
+  __loadInterceptUnauthorizeds?: readonly (() => Promise<unknown>)[] | null;
+  interceptErrors?: readonly unknown[];
+  interceptErrorTreePositions?: readonly number[];
+  __loadInterceptErrors?: readonly (() => Promise<unknown>)[] | null;
   __loadState: AppRscInterceptLoadState;
   params: readonly string[];
   slotId: string | null;
@@ -141,4 +177,5 @@ export declare function createAppRscRouteMatcher<Route extends AppRscRouteForMat
   } | null;
   findIntercept(pathname: string, sourcePathname?: string | null, interceptionId?: string | null): AppRscInterceptMatch | null;
 };
-//#endregion
+//#endregion
+export {};

package/dist/server/app-rsc-route-matching.js

@@ -209,6 +209,9 @@ function createInterceptLookup(routes) {
 					interceptLoadings: intercept.interceptLoadings,
 					interceptLoadingTreePositions: intercept.interceptLoadingTreePositions,
 					interceptNotFoundBranchSegments: intercept.interceptNotFoundBranchSegments,
+					interceptNotFounds: intercept.interceptNotFounds,
+					interceptNotFoundTreePositions: intercept.interceptNotFoundTreePositions,
+					__loadInterceptNotFounds: intercept.__loadInterceptNotFounds,
 					__loadInterceptLayouts: intercept.__loadInterceptLayouts,
 					__loadInterceptLoadings: intercept.__loadInterceptLoadings,
 					page: intercept.page,
@@ -216,6 +219,15 @@ function createInterceptLookup(routes) {
 					notFound: intercept.notFound,
 					__loadNotFound: intercept.__loadNotFound,
 					notFoundTreePosition: intercept.notFoundTreePosition,
+					interceptForbiddens: intercept.interceptForbiddens,
+					interceptForbiddenTreePositions: intercept.interceptForbiddenTreePositions,
+					__loadInterceptForbiddens: intercept.__loadInterceptForbiddens,
+					interceptUnauthorizeds: intercept.interceptUnauthorizeds,
+					interceptUnauthorizedTreePositions: intercept.interceptUnauthorizedTreePositions,
+					__loadInterceptUnauthorizeds: intercept.__loadInterceptUnauthorizeds,
+					interceptErrors: intercept.interceptErrors,
+					interceptErrorTreePositions: intercept.interceptErrorTreePositions,
+					__loadInterceptErrors: intercept.__loadInterceptErrors,
 					__loadState: {
 						page: intercept.page,
 						pageLoading: null,
@@ -248,6 +260,9 @@ function createInterceptLookup(routes) {
 				interceptLoadings: intercept.interceptLoadings,
 				interceptLoadingTreePositions: intercept.interceptLoadingTreePositions,
 				interceptNotFoundBranchSegments: intercept.interceptNotFoundBranchSegments,
+				interceptNotFounds: intercept.interceptNotFounds,
+				interceptNotFoundTreePositions: intercept.interceptNotFoundTreePositions,
+				__loadInterceptNotFounds: intercept.__loadInterceptNotFounds,
 				__loadInterceptLayouts: intercept.__loadInterceptLayouts,
 				__loadInterceptLoadings: intercept.__loadInterceptLoadings,
 				page: intercept.page,
@@ -255,6 +270,15 @@ function createInterceptLookup(routes) {
 				notFound: intercept.notFound,
 				__loadNotFound: intercept.__loadNotFound,
 				notFoundTreePosition: intercept.notFoundTreePosition,
+				interceptForbiddens: intercept.interceptForbiddens,
+				interceptForbiddenTreePositions: intercept.interceptForbiddenTreePositions,
+				__loadInterceptForbiddens: intercept.__loadInterceptForbiddens,
+				interceptUnauthorizeds: intercept.interceptUnauthorizeds,
+				interceptUnauthorizedTreePositions: intercept.interceptUnauthorizedTreePositions,
+				__loadInterceptUnauthorizeds: intercept.__loadInterceptUnauthorizeds,
+				interceptErrors: intercept.interceptErrors,
+				interceptErrorTreePositions: intercept.interceptErrorTreePositions,
+				__loadInterceptErrors: intercept.__loadInterceptErrors,
 				__loadState: {
 					page: intercept.page,
 					pageLoading: null,

package/dist/server/app-segment-config.d.ts

@@ -169,4 +169,5 @@ export declare function isAppPageStaticEligible(options: {
   isStaticGenerationEdgeRuntime: boolean;
   revalidateSeconds: number | null;
 }): boolean;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-segment-config.js

@@ -1,3 +1,4 @@
+import { compareFolderNames } from "../utils/compare.js";
 import { isEdgeApiRuntime } from "./edge-api-runtime.js";
 //#region src/server/app-segment-config.ts
 const DYNAMIC_VALUES = /* @__PURE__ */ new Set([
@@ -310,20 +311,6 @@ function hasGenerateStaticParamsExport(segment) {
 }
 const DEFAULT_SEGMENT_NAME = "__DEFAULT__";
 /**
-* Turbopack reads a folder's subfolders from a `BTreeMap<RcStr, _>`, whose
-* keys compare as Rust `str`s: by UTF-8 bytes. That is Unicode code point
-* order, which JavaScript's `<` (UTF-16 code units) doesn't match above the
-* Basic Multilingual Plane.
-* https://github.com/vercel/next.js/blob/v16.2.7/crates/next-core/src/app_structure.rs#L188-L192
-* https://github.com/vercel/next.js/blob/v16.2.7/turbopack/crates/turbo-rcstr/src/lib.rs#L350-L354
-*/
-function compareFolderNames(a, b) {
-	const left = Array.from(a, (char) => char.codePointAt(0) ?? 0);
-	const right = Array.from(b, (char) => char.codePointAt(0) ?? 0);
-	for (let index = 0; index < Math.min(left.length, right.length); index++) if (left[index] !== right[index]) return left[index] - right[index];
-	return left.length - right.length;
-}
-/**
 * Collect the loader-tree segments of an App page route from its layout, page
 * and parallel-slot modules, for `lastDynamicSegmentHasGenerateStaticParams`.
 *

package/dist/server/app-server-action-execution.d.ts

@@ -282,4 +282,5 @@ export declare function applyActionRedirectBasePath(url: string, basePath: strin
 export declare function isProgressiveServerActionRequest(request: Pick<Request, "method">, contentType: string, actionId: string | null): boolean;
 export declare function handleProgressiveServerActionRequest(options: HandleProgressiveServerActionRequestOptions): Promise<Response | ProgressiveServerActionResult | null>;
 export declare function handleServerActionRscRequest<TElement, TRoute extends AppServerActionRoute, TInterceptOpts, TTemporaryReferences, TPage = unknown>(options: HandleServerActionRscRequestOptions<TElement, TRoute, TInterceptOpts, TTemporaryReferences, TPage>): Promise<Response | null>;
-//#endregion
+//#endregion
+export {};

package/dist/server/app-server-action-execution.js

@@ -1,4 +1,5 @@
 import { runOutsideRequestScopes } from "../shims/internal/als-registry.js";
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { VINEXT_MW_CTX_HEADER } from "../utils/protocol-headers.js";
 import { buildRequestHeadersFromMiddlewareResponse } from "../utils/middleware-request-headers.js";
 import { parseEdgeRequestCookieHeader } from "../utils/parse-cookie.js";
@@ -16,17 +17,16 @@ import { isDraftModeRequest, setHeadersContext } from "../shims/headers.js";
 import { _drainPendingRevalidations, getAndClearActionRevalidationKind } from "../shims/cache-request-state.js";
 import { setCurrentFetchCacheMode, setCurrentFetchRevalidate, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
 import { readStreamAsTextWithLimit } from "../utils/text-stream.js";
-import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
 import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader, createRscRequestUrl, stripRscCacheBustingSearchParam } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 import { getNextErrorDigest, parseNextHttpErrorDigest, parseNextRedirectDigest } from "./next-error-digest.js";
 import { hasDigest } from "./app-rsc-errors.js";
-import { buildAppPageTags } from "./implicit-tags.js";
-import "./app-page-stream.js";
 import { getSetCookieName } from "./cookie-utils.js";
 import { createServerActionNotFoundResponse, getServerActionNotFoundMessage, isServerActionNotFoundError } from "./server-action-not-found.js";
 import { resolveAppPageNavigationParams } from "./app-page-element-builder.js";
+import "./app-page-stream.js";
+import { buildAppPageTags } from "./implicit-tags.js";
 import { resolveAppPageActionRerenderTarget } from "./app-page-request.js";
 import { createRootParamsUsageController, runWithRootParamsUsage } from "../shims/root-params.js";
 import { createStaticGenerationHeadersContext } from "./app-static-generation.js";

package/dist/server/app-ssr-entry.d.ts

@@ -70,6 +70,12 @@ export declare function handleSsr(rscStream: ReadableStream<Uint8Array>, navCont
    */
   isCacheCandidate?: boolean;
   fallbackToErrorDocumentOnShellError?: boolean;
+  /**
+   * The parallel slot not-found boundaries that catch the error that
+   * rejected the shell, or null when none catches it. The document then
+   * renders again from the same payload with them caught.
+   */
+  resolveCaughtNotFoundBoundaries?: (error: unknown) => readonly string[] | null;
   dynamicStaleTimeSeconds?: number;
   getInitialNavigationCacheMetadata?: () => InitialNavigationCacheMetadata;
 }): Promise<AppSsrRenderResult>;