@qzsy/vinext 0.1.12 → 0.1.80

package/dist/server/app-browser-action-result.js

@@ -41,6 +41,10 @@ function createServerActionHttpFallbackError(status) {
 function normalizeServerActionThrownValue(data, responseStatus) {
 	return createServerActionHttpFallbackError(responseStatus) ?? data;
 }
+function shouldSyncServerActionHttpFallbackHead(result) {
+	if (!isServerActionResult(result) || result.root !== void 0) return false;
+	return result.returnValue?.ok !== false;
+}
 async function readInvalidServerActionResponseError(response, hasRedirectLocation) {
 	const contentType = response.headers.get("content-type") ?? "";
 	if (contentType.startsWith("text/x-component") || hasRedirectLocation) return null;
@@ -108,4 +112,4 @@ function createDiscardedServerActionRefreshScheduler(options) {
 	};
 }
 //#endregion
-export { createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, shouldClearClientNavigationCachesForServerActionResult, shouldScheduleRefreshForDiscardedServerAction };
+export { createDiscardedServerActionRefreshScheduler, createServerActionInitiationSnapshot, createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, shouldClearClientNavigationCachesForServerActionResult, shouldScheduleRefreshForDiscardedServerAction, shouldSyncServerActionHttpFallbackHead };

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

@@ -34,14 +34,12 @@ import { AppBrowserHistoryController } from "./app-browser-history-controller.js
 import { createVisitedResponseCacheEntry, isVisitedResponseCacheEntryFresh } from "./app-visited-response-cache.js";
 import { createPopstateRestoreHandler, restoreSynchronousPopstateScrollPosition } from "./app-browser-popstate.js";
 import { createDevOnCaughtError, createOnUncaughtError, createProdOnCaughtError, prodOnRecoverableError } from "./app-browser-error.js";
-import { dismissOverlay } from "./dev-error-overlay-store.js";
-import { devOnCaughtError, installDevErrorOverlay, installViteHmrErrorHandler, reportInitialDevServerErrors } from "./dev-error-overlay.js";
 import { createOptimisticRouteTemplate, getOptimisticPrefetchSourceKey, getOptimisticRouteTemplateKey, resolveOptimisticNavigationPayload } from "./app-optimistic-routing.js";
 import { removeStylesheetLinksCoveredByInlineCss } from "./app-inline-css-client.js";
 import { createElement, startTransition, use, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
 import { flushSync } from "react-dom";
-import { createFromFetch, createFromReadableStream, setServerCallback } from "@vitejs/plugin-rsc/browser";
 import { createRoot, hydrateRoot } from "react-dom/client";
+import { createFromFetch, createFromReadableStream, setServerCallback } from "@vitejs/plugin-rsc/browser";
 import { hasServerActions, loadServerActionClient } from "virtual:vinext-app-capabilities";
 //#region src/server/app-browser-entry.ts
 function toActionType(kind) {
@@ -375,6 +373,10 @@ function storeVisitedResponseSnapshot(rscUrl, interceptionContext, snapshot, par
 function clientNavigationSnapshotHref(snapshot) {
 	return `${window.location.origin}${createSnapshotPathAndSearch(snapshot)}`;
 }
+function getCurrentMatchedRoutePathname() {
+	const routeKey = AppElementsWire.parseElementKey(getBrowserRouterState().routeId);
+	return routeKey?.kind === "route" ? routeKey.path : null;
+}
 function getRequestState(navigationKind, targetPathname, previousNextUrlOverride, traverseHistoryState) {
 	if (previousNextUrlOverride !== void 0) return {
 		interceptionContext: resolveInterceptionContextFromPreviousNextUrl(previousNextUrlOverride, __basePath),
@@ -399,6 +401,7 @@ function getRequestState(navigationKind, targetPathname, previousNextUrlOverride
 			};
 			const middlewareRewriteInterceptionContext = resolveMiddlewareRewriteNavigationInterceptionContext({
 				basePath: __basePath,
+				currentMatchedPathname: getCurrentMatchedRoutePathname(),
 				currentPathname: window.location.pathname,
 				routeManifest: getBrowserRouteManifest(),
 				targetPathname
@@ -692,24 +695,26 @@ async function main() {
 	if (!claimInitialAppRouterBootstrap()) return;
 	if (hasServerActions) registerServerActionCallback();
 	installAppNavigationFailureListeners();
+	let devErrorOverlay = null;
 	if (import.meta.env.DEV) {
-		installDevErrorOverlay();
-		installViteHmrErrorHandler(import.meta.hot);
-		reportInitialDevServerErrors();
+		devErrorOverlay = await import("../client/dev-error-overlay.js");
+		devErrorOverlay.installDevErrorOverlay();
+		devErrorOverlay.installViteHmrErrorHandler(import.meta.hot);
+		devErrorOverlay.reportInitialDevServerErrors();
 	}
 	const rscStream = await readInitialRscStream();
 	if (rscStream === null) return;
-	bootstrapHydration(rscStream);
+	bootstrapHydration(rscStream, devErrorOverlay);
 }
-function bootstrapHydration(rscStream) {
+function bootstrapHydration(rscStream, devErrorOverlay) {
 	const root = decodeAppElementsPromise(createFromReadableStream(rscStream));
 	const initialNavigationSnapshot = createClientNavigationRenderSnapshot(window.location.href, latestClientParams);
 	historyController.writeBootstrapHistoryMetadata();
 	const onUncaughtError = createOnUncaughtError();
 	const formState = consumeInitialFormState(getVinextBrowserGlobal());
-	const hydrateRootOptions = import.meta.env.DEV ? createVinextHydrateRootOptions({
+	const hydrateRootOptions = import.meta.env.DEV && devErrorOverlay ? createVinextHydrateRootOptions({
 		formState,
-		onCaughtError: createDevOnCaughtError(devOnCaughtError, onUncaughtError),
+		onCaughtError: createDevOnCaughtError(devErrorOverlay.devOnCaughtError, onUncaughtError),
 		onUncaughtError
 	}) : createVinextHydrateRootOptions({
 		formState,
@@ -1036,7 +1041,7 @@ function bootstrapHydration(rscStream) {
 			restorePopstateScrollPosition
 		}, event.state);
 	});
-	if (import.meta.hot) {
+	if (import.meta.env.DEV && import.meta.hot) {
 		const applyRscHmrUpdate = async (updateId) => {
 			if (updateId !== latestRscHmrUpdateId) return;
 			if (document.documentElement.id === "__next_error__") {
@@ -1052,7 +1057,7 @@ function bootstrapHydration(rscStream) {
 			if (!browserNavigationController.hasBrowserRouterState()) return;
 			clearClientNavigationCaches();
 			const navigationSnapshot = createClientNavigationRenderSnapshot(window.location.href, latestClientParams);
-			dismissOverlay();
+			devErrorOverlay?.dismissOverlay();
 			const hmrHeaders = createRscRequestHeaders();
 			await browserNavigationController.hmrReplaceTree(decodeAppElementsPromise(createFromFetch(fetch(await createRscRequestUrl(window.location.pathname + window.location.search, hmrHeaders), { headers: hmrHeaders }))), navigationSnapshot);
 		};

package/dist/server/app-browser-history-controller.d.ts

@@ -45,6 +45,7 @@ type CommitNavigationHistoryOptions = {
   targetHistoryIndex?: number | null;
   stageClientParams: () => void;
 };
+declare function createCanonicalBrowserHistoryHref(href: string): string;
 /**
  * Owns App Router browser-history metadata and traversal bookkeeping behind a
  * typed seam: traversal index allocation/commit, push/replace/traverse/hash-only
@@ -101,4 +102,4 @@ declare class AppBrowserHistoryController {
   restoreHistorySnapshot(options: RestoreHistorySnapshotOptions): boolean;
 }
 //#endregion
-export { AppBrowserHistoryController, RestorableSnapshotCandidate };
+export { AppBrowserHistoryController, RestorableSnapshotCandidate, createCanonicalBrowserHistoryHref };

package/dist/server/app-browser-history-controller.js

@@ -1,5 +1,9 @@
 import { RestorableClientStateController, createHistoryStateWithNavigationMetadata, readHistoryStateBfcacheIds, readHistoryStatePreviousNextUrl, readHistoryStateTraversalIndex, resolveHistoryTraversalIntent } from "./app-history-state.js";
 //#region src/server/app-browser-history-controller.ts
+function createCanonicalBrowserHistoryHref(href) {
+	const url = new URL(href);
+	return `${url.pathname}${url.search}${url.hash}`;
+}
 function stripVinextScrollState(state) {
 	if (!state || typeof state !== "object") return state;
 	const nextState = {};
@@ -166,7 +170,7 @@ var AppBrowserHistoryController = class {
 		this.#replaceHistoryState(createHistoryStateWithNavigationMetadata(this.#readHistoryState(), {
 			previousNextUrl: null,
 			traversalIndex: this.#currentHistoryTraversalIndex
-		}), this.#readCurrentHref());
+		}), createCanonicalBrowserHistoryHref(this.#readCurrentHref()));
 	}
 	/** History write performed on the first committed (hydrated) render. */
 	writeHydratedHistoryMetadata(options) {
@@ -207,4 +211,4 @@ function areBfcacheIdMapsEqual(a, b) {
 	return aEntries.every(([key, value]) => b[key] === value);
 }
 //#endregion
-export { AppBrowserHistoryController };
+export { AppBrowserHistoryController, createCanonicalBrowserHistoryHref };

package/dist/server/app-browser-interception-context.d.ts

@@ -3,6 +3,7 @@ import { RouteManifest } from "../routing/app-route-graph.js";
 //#region src/server/app-browser-interception-context.d.ts
 type ResolveManifestNavigationInterceptionContextOptions = {
   basePath: string;
+  currentMatchedPathname?: string | null;
   currentPathname: string;
   routeManifest: RouteManifest | null;
   targetPathname: string;

package/dist/server/app-browser-interception-context.js

@@ -29,13 +29,15 @@ function resolveManifestNavigationInterceptionContext(options) {
 function resolveMiddlewareRewriteNavigationInterceptionContext(options) {
 	if (options.routeManifest === null) return null;
 	const currentPathname = stripBasePath(options.currentPathname, options.basePath);
+	const currentMatchedPathname = options.currentMatchedPathname ? stripBasePath(options.currentMatchedPathname, options.basePath) : null;
 	const targetPathname = stripBasePath(options.targetPathname, options.basePath);
 	const sourceParts = splitPathnameForRouteMatch(currentPathname);
+	const matchedSourceParts = currentMatchedPathname ? splitPathnameForRouteMatch(currentMatchedPathname) : null;
 	const targetParts = splitPathnameForRouteMatch(targetPathname);
 	for (const interception of options.routeManifest.segmentGraph.interceptions.values()) {
-		if (!matchRoutePatternPrefix(sourceParts, interception.sourcePatternParts)) continue;
 		if (!matchRoutePatternWithOptionalDynamicSegments(targetParts, interception.targetPatternParts)) continue;
-		return currentPathname;
+		if (matchRoutePatternPrefix(sourceParts, interception.sourcePatternParts)) return currentPathname;
+		if (currentMatchedPathname !== null && matchedSourceParts !== null && matchRoutePatternPrefix(matchedSourceParts, interception.sourcePatternParts)) return currentMatchedPathname;
 	}
 	return null;
 }

package/dist/server/app-browser-navigation-controller.js

@@ -280,6 +280,7 @@ function createAppBrowserNavigationController(deps = {}) {
 			previousNextUrl: options.restoredState.previousNextUrl,
 			rootLayoutTreePath: options.restoredState.rootLayoutTreePath,
 			routeId: options.restoredState.routeId,
+			restoredHistorySnapshot: true,
 			skippedLayoutIds: []
 		};
 	}

package/dist/server/app-browser-server-action-client.js

@@ -3,7 +3,7 @@ import { DANGEROUS_URL_BLOCK_MESSAGE, isDangerousScheme } from "../shims/url-saf
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
 import { VINEXT_RSC_COMPATIBILITY_ID_HEADER, createServerActionRequestUrl } from "./app-rsc-cache-busting.js";
-import { createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, shouldClearClientNavigationCachesForServerActionResult } from "./app-browser-action-result.js";
+import { createServerActionResultFacts, isServerActionResult, normalizeServerActionThrownValue, parseServerActionRevalidationHeader, readInvalidServerActionResponseError, shouldClearClientNavigationCachesForServerActionResult, shouldSyncServerActionHttpFallbackHead } from "./app-browser-action-result.js";
 import { resolveServerActionRequestState } from "./app-browser-state.js";
 import { applyServerActionResultDecision } from "./app-browser-server-action-navigation.js";
 import { throwOnServerActionNotFound } from "./server-action-not-found.js";
@@ -106,8 +106,7 @@ async function invokeClientServerAction(id, args, actionInitiation, deps) {
 		deps.performHardNavigation(actionRedirectTarget.href);
 		return;
 	}
-	const hasSameUrlRerenderPayload = isServerActionResult(result) && result.root !== void 0;
-	deps.syncServerActionHttpFallbackHead(hasSameUrlRerenderPayload ? null : fetchResponse.status);
+	deps.syncServerActionHttpFallbackHead(shouldSyncServerActionHttpFallbackHead(result) ? fetchResponse.status : null);
 	if (isServerActionResult(result)) {
 		if (result.root !== void 0) {
 			const returnValue = result.returnValue && !result.returnValue.ok ? {

package/dist/server/app-browser-state.d.ts

@@ -64,6 +64,7 @@ type PendingNavigationCommit = {
   previousNextUrl: string | null;
   rootLayoutTreePath: string | null;
   routeId: string;
+  restoredHistorySnapshot?: boolean;
   skippedLayoutIds: readonly string[];
 };
 type AppNavigationPayloadOrigin = Readonly<{

package/dist/server/app-browser-state.js

@@ -126,7 +126,7 @@ function createMountedParallelSlotSnapshots(elements) {
 }
 function createVisibleRouteSnapshot(state) {
 	const displayUrl = createSnapshotPathAndSearch(state.navigationSnapshot);
-	const matchedUrl = normalizeNavigationSnapshotMatchedUrl(state.navigationSnapshot.pathname);
+	const matchedUrl = state.interception?.targetMatchedUrl ?? normalizeNavigationSnapshotMatchedUrl(state.navigationSnapshot.pathname);
 	return {
 		displayUrl,
 		interception: state.interception,
@@ -144,7 +144,7 @@ function createVisibleRouteSnapshot(state) {
 }
 function createPendingRouteSnapshot(pending) {
 	const displayUrl = createSnapshotPathAndSearch(pending.action.navigationSnapshot);
-	const matchedUrl = normalizeNavigationSnapshotMatchedUrl(pending.action.navigationSnapshot.pathname);
+	const matchedUrl = pending.action.interception?.targetMatchedUrl ?? normalizeNavigationSnapshotMatchedUrl(pending.action.navigationSnapshot.pathname);
 	return {
 		displayUrl,
 		interception: pending.action.interception,
@@ -188,6 +188,7 @@ function planPendingRootBoundaryFlightResponse(options) {
 			kind: "flightResponseArrived",
 			result: {
 				...cacheEntryReuseProof ? { cacheEntryReuseProof } : {},
+				...options.pending.restoredHistorySnapshot ? { restoredHistorySnapshot: true } : {},
 				href: options.targetHref ?? options.targetSnapshot.displayUrl,
 				targetSnapshot: options.targetSnapshot
 			},

package/dist/server/app-fallback-renderer.d.ts

@@ -33,7 +33,8 @@ type AppFallbackRendererOptions<TModule extends AppPageModule = AppPageModule> =
   createRscOnErrorHandler: (request: Request, pathname: string, routePath: string) => AppPageBoundaryOnError;
   fontProviders: AppFallbackRendererFontProviders;
   getNavigationContext: () => NavigationContext | null;
-  globalErrorModule?: TModule | null;
+  globalErrorModule?: TModule | null; /** Whether experimental.globalNotFound is enabled for route-miss 404s. */
+  globalNotFoundEnabled?: boolean;
   /**
    * Loader for the user's `app/global-not-found.tsx` module. When provided,
    * route-miss 404s render this module as a standalone document (skipping the
@@ -75,7 +76,7 @@ type AppFallbackRendererCallContext = {
   sourcePageSegments?: readonly string[] | null;
 };
 type AppFallbackRenderer<TModule extends AppPageModule = AppPageModule> = {
-  renderErrorBoundary: (route: AppPageBoundaryRoute<TModule> | null, error: unknown, isRscRequest: boolean, request: Request, matchedParams: AppPageParams | undefined, scriptNonce: string | undefined, middlewareContext: AppPageMiddlewareContext, callContext?: AppFallbackRendererCallContext) => Promise<Response | null>;
+  renderErrorBoundary: (route: AppPageBoundaryRoute<TModule> | null, error: unknown, isRscRequest: boolean, request: Request, matchedParams: AppPageParams | undefined, scriptNonce: string | undefined, middlewareContext: AppPageMiddlewareContext, callContext?: AppFallbackRendererCallContext, errorOrigin?: "rsc" | "ssr") => Promise<Response | null>;
   renderHttpAccessFallback: (route: AppPageBoundaryRoute<TModule> | null, statusCode: number, isRscRequest: boolean, request: Request, opts: {
     boundaryComponent?: AppPageComponent | null;
     boundaryModule?: TModule | null;

package/dist/server/app-fallback-renderer.js

@@ -1,5 +1,6 @@
 import { renderAppPageErrorBoundary, renderAppPageHttpAccessFallback } from "./app-page-boundary-render.js";
 import { DEFAULT_GLOBAL_ERROR_MODULE } from "./default-global-error-module.js";
+import { DEFAULT_GLOBAL_NOT_FOUND_MODULE } from "./default-global-not-found-module.js";
 import { DEFAULT_NOT_FOUND_MODULE } from "./default-not-found-module.js";
 //#region src/server/app-fallback-renderer.ts
 const EMPTY_MW_CTX = {
@@ -7,7 +8,7 @@ const EMPTY_MW_CTX = {
 	status: null
 };
 function createAppFallbackRenderer(options) {
-	const { applyFileBasedMetadata, basePath = "", clearRequestContext, createRscOnErrorHandler: buildRscOnErrorHandler, fontProviders, getNavigationContext, globalErrorModule, loadGlobalNotFoundModule, makeThenableParams, metadataRoutes, resolveChildSegments, rootBoundaries, rscRenderer, sanitizer, ssrLoader, trailingSlash } = options;
+	const { applyFileBasedMetadata, basePath = "", clearRequestContext, createRscOnErrorHandler: buildRscOnErrorHandler, fontProviders, getNavigationContext, globalErrorModule, globalNotFoundEnabled = false, loadGlobalNotFoundModule, makeThenableParams, metadataRoutes, resolveChildSegments, rootBoundaries, rscRenderer, sanitizer, ssrLoader, trailingSlash } = options;
 	const { rootForbiddenModule, rootLayouts, rootNotFoundModule, rootUnauthorizedModule } = rootBoundaries;
 	const effectiveGlobalErrorModule = globalErrorModule ?? DEFAULT_GLOBAL_ERROR_MODULE;
 	const effectiveRootNotFoundModule = rootNotFoundModule ?? DEFAULT_NOT_FOUND_MODULE;
@@ -19,7 +20,8 @@ function createAppFallbackRenderer(options) {
 	}
 	return {
 		async renderHttpAccessFallback(route, statusCode, isRscRequest, request, opts, scriptNonce, middlewareContext, callContext) {
-			if (statusCode === 404 && !!loadGlobalNotFoundModule && !route && !opts?.boundaryComponent) {
+			const useGlobalNotFound = statusCode === 404 && globalNotFoundEnabled && !route && !opts?.boundaryComponent;
+			if (useGlobalNotFound && loadGlobalNotFoundModule) {
 				const globalNotFoundModule = await resolveGlobalNotFoundModule();
 				const globalNotFoundComponent = globalNotFoundModule?.default ?? null;
 				if (globalNotFoundComponent) return renderAppPageHttpAccessFallback({
@@ -57,6 +59,7 @@ function createAppFallbackRenderer(options) {
 					statusCode
 				});
 			}
+			const routeMissRootNotFoundModule = useGlobalNotFound ? DEFAULT_GLOBAL_NOT_FOUND_MODULE : effectiveRootNotFoundModule;
 			return renderAppPageHttpAccessFallback({
 				applyFileBasedMetadata,
 				basePath,
@@ -75,7 +78,7 @@ function createAppFallbackRenderer(options) {
 				globalErrorModule: effectiveGlobalErrorModule,
 				isEdgeRuntime: callContext?.isEdgeRuntime,
 				isRscRequest,
-				layoutModules: opts?.layouts ?? null,
+				layoutModules: useGlobalNotFound ? [] : opts?.layouts ?? null,
 				loadSsrHandler: ssrLoader,
 				makeThenableParams,
 				matchedParams: opts?.matchedParams ?? route?.params ?? {},
@@ -84,12 +87,13 @@ function createAppFallbackRenderer(options) {
 				requestUrl: request.url,
 				resolveChildSegments,
 				rootForbiddenModule,
-				rootLayouts,
-				rootNotFoundModule: effectiveRootNotFoundModule,
+				rootLayouts: useGlobalNotFound ? [] : rootLayouts,
+				rootNotFoundModule: routeMissRootNotFoundModule,
 				rootUnauthorizedModule,
-				route,
+				route: useGlobalNotFound ? null : route,
 				renderToReadableStream: rscRenderer,
 				scriptNonce,
+				skipLayoutWrapping: useGlobalNotFound,
 				sourcePageSegments: callContext?.sourcePageSegments,
 				statusCode
 			});
@@ -97,7 +101,7 @@ function createAppFallbackRenderer(options) {
 		renderNotFound(route, isRscRequest, request, matchedParams, scriptNonce, middlewareContext, callContext) {
 			return this.renderHttpAccessFallback(route, 404, isRscRequest, request, { matchedParams }, scriptNonce, middlewareContext, callContext);
 		},
-		renderErrorBoundary(route, error, isRscRequest, request, matchedParams, scriptNonce, middlewareContext, callContext) {
+		renderErrorBoundary(route, error, isRscRequest, request, matchedParams, scriptNonce, middlewareContext, callContext, errorOrigin = "rsc") {
 			return renderAppPageErrorBoundary({
 				applyFileBasedMetadata,
 				basePath,
@@ -108,6 +112,7 @@ function createAppFallbackRenderer(options) {
 					return buildRscOnErrorHandler(request, pathname, routePath);
 				},
 				error,
+				errorOrigin,
 				getFontLinks: fontProviders.getFontLinks,
 				getFontPreloads: fontProviders.getFontPreloads,
 				getFontStyles: fontProviders.getFontStyles,

package/dist/server/app-middleware.d.ts

@@ -14,9 +14,8 @@ type ApplyAppMiddlewareOptions = {
   context: AppMiddlewareContext;
   i18nConfig?: NextI18nConfig | null;
   /**
-   * Whether the inbound request was a `_next/data` fetch. Captured from the
-   * raw incoming headers by the caller, because `x-nextjs-data` is in
-   * INTERNAL_HEADERS and is stripped before this function runs.
+   * Whether the inbound request was recognized as a `_next/data` fetch from
+   * trusted URL normalization before internal headers were stripped.
    */
   isDataRequest?: boolean;
   filePath?: string;

package/dist/server/app-middleware.js

@@ -1,5 +1,6 @@
-import { FLIGHT_HEADERS, VINEXT_MW_CTX_HEADER } from "./headers.js";
-import { buildRequestHeadersFromMiddlewareResponse } from "./middleware-request-headers.js";
+import { VINEXT_MW_CTX_HEADER } from "../utils/protocol-headers.js";
+import { FLIGHT_HEADERS } from "./headers.js";
+import { buildRequestHeadersFromMiddlewareResponse } from "../utils/middleware-request-headers.js";
 import { isExternalUrl, proxyExternalRequest } from "../config/config-matchers.js";
 import { internalServerErrorResponse } from "./http-error-responses.js";
 import { cloneRequestWithHeaders, processMiddlewareHeaders } from "./request-pipeline.js";

package/dist/server/app-optimistic-routing.js

@@ -1,9 +1,9 @@
 import { buildParams, decodeMatchedParams, splitPathnameForRouteMatch } from "../routing/utils.js";
 import { stripBasePath } from "../utils/base-path.js";
-import { matchRoutePattern } from "../routing/route-pattern.js";
 import { isUnknownRecord } from "../utils/record.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
+import { matchRoutePattern } from "../routing/route-pattern.js";
 import { stripRscCacheBustingSearchParam, stripRscSuffix } from "./app-rsc-cache-busting.js";
 import { Suspense, createElement, isValidElement } from "react";
 //#region src/server/app-optimistic-routing.ts

package/dist/server/app-page-boundary-render.d.ts

@@ -75,6 +75,7 @@ type RenderAppPageHttpAccessFallbackOptions<TModule extends AppPageModule = AppP
 } & AppPageBoundaryRenderCommonOptions<TModule>;
 type RenderAppPageErrorBoundaryOptions<TModule extends AppPageModule = AppPageModule> = {
   error: unknown;
+  errorOrigin?: "rsc" | "ssr";
   matchedParams?: AppPageParams | null;
   route?: AppPageBoundaryRoute<TModule> | null;
   sanitizeErrorForClient: (error: Error) => Error;

package/dist/server/app-page-boundary-render.js

@@ -3,7 +3,7 @@ import { AppElementsWire } from "./app-elements-wire.js";
 import "./app-elements.js";
 import DefaultGlobalError from "../shims/default-global-error.js";
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
-import { ErrorBoundary, GlobalErrorBoundary } from "../shims/error-boundary.js";
+import { ErrorBoundary, GlobalErrorBoundary, SerializedErrorBoundary } from "../shims/error-boundary.js";
 import { LayoutSegmentProvider } from "../shims/layout-segment-context.js";
 import { MetadataHead, ViewportHead } from "../shims/metadata.js";
 import { resolveAppPageSpecialError } from "./app-page-execution.js";
@@ -215,7 +215,7 @@ async function renderAppPageErrorBoundary(options) {
 	if (!errorBoundary.component) return null;
 	const rawError = options.error instanceof Error ? options.error : new Error(String(options.error));
 	rewriteClientHookError(rawError);
-	const errorObject = options.sanitizeErrorForClient(rawError);
+	const errorObject = options.errorOrigin === "ssr" ? rawError : options.sanitizeErrorForClient(rawError);
 	const matchedParams = options.matchedParams ?? options.route?.params ?? {};
 	const layoutModules = options.route?.layouts ?? options.rootLayouts;
 	const pathname = new URL(options.requestUrl).pathname;
@@ -249,7 +249,16 @@ async function renderAppPageErrorBoundary(options) {
 		console.error(`[vinext] App page error boundary head resolution failed for ${options.route?.pattern ?? pathname}:`, error);
 	}
 	const buildElement = (BoundaryComponent) => {
-		const boundaryElement = createElement(BoundaryComponent, { error: errorObject });
+		const serializedError = {
+			digest: "digest" in errorObject ? String(errorObject.digest) : void 0,
+			message: errorObject.message,
+			name: errorObject.name,
+			stack: process.env.NODE_ENV !== "production" ? errorObject.stack : void 0
+		};
+		const boundaryElement = errorBoundary.isGlobalError && BoundaryComponent !== DEFAULT_GLOBAL_ERROR_COMPONENT ? createElement(SerializedErrorBoundary, {
+			error: serializedError,
+			fallback: BoundaryComponent
+		}) : createElement(BoundaryComponent, { error: errorObject });
 		return wrapRenderedBoundaryElement({
 			element: createElement(Fragment, null, ...headElements, errorBoundary.isGlobalError ? createElement(GlobalErrorBoundary, {
 				fallback: DEFAULT_GLOBAL_ERROR_COMPONENT,

package/dist/server/app-page-cache-finalizer.d.ts

@@ -30,6 +30,7 @@ type FinalizeAppPageHtmlCacheResponseOptions = {
   isrRscKey: AppPageRscCacheKeyBuilder;
   isrSet: AppPageCacheSetter;
   interceptionContext?: string | null;
+  omitPendingDynamicCacheState?: boolean;
   preserveClientResponseHeaders?: boolean;
   expireSeconds?: number;
   revalidateSeconds: number | null;

package/dist/server/app-page-cache-finalizer.js

@@ -1,15 +1,21 @@
+import { NEXTJS_CACHE_HEADER, VINEXT_CACHE_HEADER } from "./headers.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
 import { applyCdnResponseHeaders } from "./cache-control.js";
 import { buildAppPageCacheValue } from "./isr-cache.js";
 import { readStreamAsText } from "../utils/text-stream.js";
 import { createEmptyAppPageRenderObservationState } from "./app-page-render-observation.js";
 //#region src/server/app-page-cache-finalizer.ts
-function applyPendingDynamicCdnHeaders(headers, tags) {
+function applyPendingDynamicCdnHeaders(headers, tags, options = {}) {
 	applyCdnResponseHeaders(headers, {
 		cacheControl: headers.get("Cache-Control") ?? "",
 		pendingDynamicCheck: true,
 		tags
 	});
+	if (options.omitCacheState === true) {
+		headers.delete(VINEXT_CACHE_HEADER);
+		headers.delete(NEXTJS_CACHE_HEADER);
+		return;
+	}
 	setCacheStateHeaders(headers, "MISS");
 }
 function resolveAppPageCacheWritePolicy(options) {
@@ -30,7 +36,7 @@ function finalizeAppPageHtmlCacheResponse(response, options) {
 	const htmlKey = options.isrHtmlKey(options.cleanPathname);
 	const rscKey = options.isrRscKey(options.cleanPathname, null, void 0, options.interceptionContext);
 	const clientHeaders = new Headers(response.headers);
-	if (options.preserveClientResponseHeaders !== true) applyPendingDynamicCdnHeaders(clientHeaders, options.getPageTags());
+	if (options.preserveClientResponseHeaders !== true) applyPendingDynamicCdnHeaders(clientHeaders, options.getPageTags(), { omitCacheState: options.omitPendingDynamicCacheState === true });
 	const cachePromise = (async () => {
 		try {
 			const cachedHtml = await readStreamAsText(streamForCache);
@@ -57,7 +63,8 @@ function finalizeAppPageHtmlCacheResponse(response, options) {
 				cacheTags: pageTags,
 				state: observationState
 			});
-			const writes = [options.isrSet(htmlKey, buildAppPageCacheValue(cachedHtml, void 0, 200, htmlRenderObservation), cachePolicy.revalidateSeconds, pageTags, cachePolicy.expireSeconds)];
+			const linkHeader = response.headers.get("link");
+			const writes = [options.isrSet(htmlKey, buildAppPageCacheValue(cachedHtml, void 0, 200, htmlRenderObservation, linkHeader ? { link: linkHeader } : void 0), cachePolicy.revalidateSeconds, pageTags, cachePolicy.expireSeconds)];
 			if (options.capturedRscDataPromise) writes.push(options.capturedRscDataPromise.then((rscData) => options.isrSet(rscKey, buildAppPageCacheValue("", rscData, 200, rscRenderObservation), cachePolicy.revalidateSeconds, pageTags, cachePolicy.expireSeconds)));
 			await Promise.all(writes);
 			options.isrDebug?.("HTML cache written", htmlKey);

package/dist/server/app-page-cache-render.d.ts

@@ -38,6 +38,7 @@ type RenderAppPageCacheArtifactsResult = {
   cacheControl?: CacheControlMetadata;
   html: string;
   htmlRenderObservation: ReturnType<typeof createAppPageRenderObservation>;
+  linkHeader?: string;
   rscData?: ArrayBuffer;
   rscRenderObservation?: ReturnType<typeof createAppPageRenderObservation>;
   tags: string[];

package/dist/server/app-page-cache-render.js

@@ -2,9 +2,9 @@ import { consumeDynamicUsage, consumeInvalidDynamicUsageError } from "../shims/h
 import { _consumeRequestScopedCacheLife } from "../shims/cache-request-state.js";
 import { getCollectedFetchTags } from "../shims/fetch-cache.js";
 import { readStreamAsText } from "../utils/text-stream.js";
-import { teeAppPageRscStreamForCapture } from "./app-page-execution.js";
+import { buildAppPageFontLinkHeader, teeAppPageRscStreamForCapture } from "./app-page-execution.js";
 import { consumeAppPageRenderObservationState, createAppPageHtmlOutputScope, createAppPageRenderObservation, createAppPageRscOutputScope } from "./app-page-render-observation.js";
-import { isAppSsrRenderResult } from "./app-page-stream.js";
+import { buildAppPageLinkHeader, isAppSsrRenderResult } from "./app-page-stream.js";
 import { buildAppPageTags } from "./implicit-tags.js";
 //#region src/server/app-page-cache-render.ts
 /**
@@ -16,10 +16,11 @@ import { buildAppPageTags } from "./implicit-tags.js";
 async function renderAppPageCacheArtifacts(options) {
 	const rscCapture = teeAppPageRscStreamForCapture(options.renderToReadableStream(options.element, { onError: options.onError }), options.captureRscData);
 	const capturedRscDataRef = { value: null };
+	const fontPreloads = options.getFontPreloads();
 	const htmlResult = await (await options.loadSsrHandler()).handleSsr(rscCapture.ssrStream, options.getNavigationContext(), {
 		links: options.getFontLinks(),
 		styles: options.getFontStyles(),
-		preloads: options.getFontPreloads()
+		preloads: fontPreloads
 	}, {
 		basePath: options.basePath,
 		clientTraceMetadata: options.clientTraceMetadata,
@@ -31,7 +32,9 @@ async function renderAppPageCacheArtifacts(options) {
 			capturedRscDataRef
 		} : {}
 	});
-	const html = await readStreamAsText(isAppSsrRenderResult(htmlResult) ? htmlResult.htmlStream : htmlResult);
+	const htmlStream = isAppSsrRenderResult(htmlResult) ? htmlResult.htmlStream : htmlResult;
+	const linkHeader = buildAppPageLinkHeader(isAppSsrRenderResult(htmlResult) ? htmlResult.linkHeader : void 0, buildAppPageFontLinkHeader(fontPreloads), options.reactMaxHeadersLength);
+	const html = await readStreamAsText(htmlStream);
 	let rscData;
 	if (options.captureRscData) {
 		const capturedPromise = capturedRscDataRef.value;
@@ -60,6 +63,7 @@ async function renderAppPageCacheArtifacts(options) {
 			params: options.navigationParams,
 			state: observationState
 		}),
+		...linkHeader ? { linkHeader } : {},
 		tags,
 		cacheControl: typeof cacheLife?.revalidate === "number" ? {
 			revalidate: cacheLife.revalidate,

package/dist/server/app-page-cache.d.ts

@@ -25,6 +25,7 @@ type AppPageCacheRenderResult = {
   cacheControl?: CacheControlMetadata;
   html: string;
   htmlRenderObservation?: RenderObservation;
+  linkHeader?: string;
   rscData: ArrayBuffer;
   rscRenderObservation?: RenderObservation;
   tags: string[];

package/dist/server/app-page-cache.js

@@ -43,6 +43,8 @@ function buildAppPageCachedHeaders(options) {
 	applyCdnResponseHeaders(headers, { cacheControl: options.cacheControl });
 	setCacheStateHeaders(headers, options.cacheState);
 	applyEdgeRuntimeHeader(headers, options.isEdgeRuntime);
+	if (options.linkHeader) if (Array.isArray(options.linkHeader)) for (const value of options.linkHeader) headers.append("Link", value);
+	else headers.set("Link", options.linkHeader);
 	if (options.mountedSlotsHeader) headers.set(VINEXT_MOUNTED_SLOTS_HEADER, options.mountedSlotsHeader);
 	mergeMiddlewareResponseHeaders(headers, options.middlewareHeaders ?? null);
 	return headers;
@@ -84,6 +86,7 @@ function buildAppPageCachedResponse(cachedValue, options) {
 		cacheState: options.cacheState,
 		contentType: "text/html; charset=utf-8",
 		isEdgeRuntime: options.isEdgeRuntime,
+		linkHeader: cachedValue.headers?.link,
 		middlewareHeaders: options.middlewareHeaders
 	});
 	return new Response(cachedValue.html, {
@@ -177,7 +180,7 @@ async function readAppPageCacheResponse(options) {
 				const revalidateSeconds = revalidatedPage.cacheControl?.revalidate ?? options.revalidateSeconds;
 				const expireSeconds = revalidatedPage.cacheControl?.expire ?? options.expireSeconds;
 				const writes = [options.isrSet(options.isRscRequest ? isrKey : options.isrRscKey(options.cleanPathname, options.mountedSlotsHeader, options.renderMode, options.interceptionContext), buildAppPageCacheValue("", revalidatedPage.rscData, 200, revalidatedPage.rscRenderObservation), revalidateSeconds, revalidatedPage.tags, expireSeconds)];
-				if (!options.isRscRequest) writes.push(options.isrSet(isrKey, buildAppPageCacheValue(revalidatedPage.html, void 0, 200, revalidatedPage.htmlRenderObservation), revalidateSeconds, revalidatedPage.tags, expireSeconds));
+				if (!options.isRscRequest) writes.push(options.isrSet(isrKey, buildAppPageCacheValue(revalidatedPage.html, void 0, 200, revalidatedPage.htmlRenderObservation, revalidatedPage.linkHeader ? { link: revalidatedPage.linkHeader } : void 0), revalidateSeconds, revalidatedPage.tags, expireSeconds));
 				await Promise.all(writes);
 				options.isrDebug?.("regen complete", options.cleanPathname);
 			});

package/dist/server/app-page-dispatch.d.ts

@@ -34,7 +34,10 @@ type AppPageBackgroundRegenerationErrorContext = {
 type AppPageBackgroundRegenerator = (key: string, renderFn: () => Promise<void>, errorContext?: AppPageBackgroundRegenerationErrorContext) => void;
 type AppPageDispatchIntercept<TPage = unknown> = {
   interceptLayouts?: readonly unknown[] | null;
+  interceptLayoutSegments?: readonly (readonly string[])[] | null;
+  interceptBranchSegments?: readonly string[] | null;
   matchedParams: AppPageParams;
+  sourceMatchedParams?: AppPageParams;
   page: TPage;
   slotId?: string | null;
   slotKey: string;
@@ -44,6 +47,8 @@ type AppPageDispatchIntercept<TPage = unknown> = {
 type AppPageDispatchInterceptOptions<TPage = unknown> = {
   interceptionContext: string | null;
   interceptLayouts?: readonly unknown[] | null;
+  interceptLayoutSegments?: readonly (readonly string[])[] | null;
+  interceptBranchSegments?: readonly string[] | null;
   interceptPage: TPage;
   interceptParams: AppPageParams;
   interceptSlotId?: string | null;
@@ -104,7 +109,10 @@ type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
    * `next.config`. Undefined falls back to the React default downstream.
    */
   reactMaxHeadersLength?: number;
-  buildPageElement: (route: TRoute, params: AppPageParams, opts: AppPageDispatchInterceptOptions | undefined, searchParams: URLSearchParams, layoutParamAccess?: AppLayoutParamAccessTracker) => Promise<AppPageElement>;
+  buildPageElement: (route: TRoute, params: AppPageParams, opts: AppPageDispatchInterceptOptions | undefined, searchParams: URLSearchParams, layoutParamAccess?: AppLayoutParamAccessTracker, options?: {
+    observeMetadataSearchParamsAccess?: boolean;
+    observePageSearchParamsAccess?: boolean;
+  }) => Promise<AppPageElement>;
   clientReuseManifest?: ClientReuseManifestParseResult;
   cleanPathname: string;
   displayPathname?: string;
@@ -170,9 +178,9 @@ type DispatchAppPageOptions<TRoute extends AppPageDispatchRoute> = {
   staticParamsValidationParams?: AppPageParams;
   rootParams?: RootParams;
   probeLayoutAt: (layoutIndex: number, layoutParamAccess?: AppLayoutParamAccessTracker) => unknown;
-  probePage: () => unknown;
+  probePage: (searchParams?: URLSearchParams) => unknown;
   expireSeconds?: number;
-  renderErrorBoundaryPage: (error: unknown) => Promise<Response | null>;
+  renderErrorBoundaryPage: (error: unknown, errorOrigin?: "rsc" | "ssr") => Promise<Response | null>;
   renderHttpAccessFallbackPage: (statusCode: number, opts: {
     boundaryComponent?: unknown;
     boundaryModule?: AppPageModule | null;