@qzsy/vinext 0.1.12 → 0.1.122

package/dist/routing/app-route-graph.js

@@ -360,8 +360,8 @@ async function buildAppRouteGraph(appDir, matcher) {
 	const routePatterns = new Set(routes.map((route) => route.pattern));
 	const ghostParentRoutes = [];
 	for await (const file of scanWithExtensions("**/layout", appDir, scanMatcher.extensions, excludeDir)) {
-		const dir = path.dirname(file);
-		const routeDir = dir === "." ? appDir : path.join(appDir, dir);
+		const dir = path.posix.dirname(file);
+		const routeDir = dir === "." ? appDir : path.posix.join(appDir, dir);
 		if (!hasParallelSlotDirectory(routeDir)) continue;
 		if (discoverParallelSlots(routeDir, appDir, scanMatcher).length === 0) continue;
 		const route = directoryToAppRoute(dir, appDir, scanMatcher, null, null);
@@ -434,11 +434,16 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 	const applySlotSubPages = (route, slotPages, rawSegments) => {
 		route.parallelSlots = route.parallelSlots.map((slot) => {
 			const subPage = slotPages.get(slot.key);
-			if (subPage !== void 0) return {
-				...slot,
-				pagePath: subPage,
-				routeSegments: rawSegments
-			};
+			if (subPage !== void 0) {
+				const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, subPage, matcher);
+				return {
+					...slot,
+					pagePath: subPage,
+					configLayoutPaths,
+					configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
+					routeSegments: rawSegments
+				};
+			}
 			return slot;
 		});
 	};
@@ -495,9 +500,12 @@ function discoverSlotSubRoutes(routes, matcher, ghostParents = []) {
 			if (Array.from(routesByPattern.values()).some((r) => patternsStructurallyEquivalent(r.patternParts, syntheticParts))) continue;
 			const subSlots = parentRoute.parallelSlots.map((slot) => {
 				const subPage = slotPages.get(slot.key);
+				const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, subPage ?? null, matcher);
 				return {
 					...slot,
 					pagePath: subPage || null,
+					configLayoutPaths,
+					configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
 					routeSegments: subPage ? rawSegments : null
 				};
 			});
@@ -574,6 +582,23 @@ function findSlotSubPages(slotDir, matcher) {
 	perMatcher.set(slotDir, results);
 	return results;
 }
+function findSlotConfigLayoutPaths(slotDir, pagePath, matcher) {
+	if (!pagePath) return [];
+	const layouts = [];
+	let dir = path.dirname(pagePath);
+	while (dir !== slotDir && dir.startsWith(`${slotDir}${path.sep}`)) {
+		const layoutPath = findFile(dir, "layout", matcher);
+		if (layoutPath) layouts.unshift(layoutPath);
+		dir = path.dirname(dir);
+	}
+	return layouts;
+}
+function findSlotConfigLayoutTreePositions(slotDir, layoutPaths) {
+	return layoutPaths.map((layoutPath) => {
+		const relativeDir = path.relative(slotDir, path.dirname(layoutPath));
+		return relativeDir ? relativeDir.split(path.sep).filter(Boolean).length : 0;
+	});
+}
 /**
 * Find a sibling catch-all page directly under `dir`, i.e. a `[...slug]` or
 * `[[...slug]]` directory that contains a `page` file. Returns the absolute
@@ -613,8 +638,14 @@ function fileToAppRoute(file, appDir, type, matcher) {
 	}
 	return directoryToAppRoute(dir, appDir, matcher, type === "page" ? path.join(appDir, file) : null, type === "route" ? path.join(appDir, file) : null);
 }
+/**
+* `dir` and `appDir` must both be forward-slash. `dir` is split on
+* `path.posix.sep` and joined onto `appDir` with `path.posix.join`, and `appDir`
+* is threaded to the layout/slot/boundary discovery below, which build paths the
+* same way.
+*/
 function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
-	const segments = dir === "." ? [] : dir.split(path.sep);
+	const segments = dir === "." ? [] : dir.split(path.posix.sep);
 	const params = [];
 	let isDynamic = false;
 	const convertedRoute = convertSegmentsToRouteParts(segments);
@@ -631,7 +662,7 @@ function directoryToAppRoute(dir, appDir, matcher, pagePath, routePath) {
 	const errorEntries = discoverSegmentErrors(segments, appDir, matcher);
 	const errorPaths = errorEntries.map((entry) => entry.path);
 	const errorTreePositions = errorEntries.map((entry) => entry.treePosition);
-	const routeDir = dir === "." ? appDir : path.join(appDir, dir);
+	const routeDir = dir === "." ? appDir : path.posix.join(appDir, dir);
 	const loadingPath = findFile(routeDir, "loading", matcher);
 	const errorPath = findFile(routeDir, "error", matcher);
 	const notFoundPath = discoverBoundaryFile(segments, appDir, "not-found", matcher);
@@ -863,6 +894,10 @@ function discoverBoundaryFilePerLayout(layouts, fileName, matcher) {
 * Walk from appDir through each segment to the route's directory. At each level
 * that has @slot dirs, collect them. Slots at the route's own directory level
 * use page.tsx; slots at ancestor levels use default.tsx only.
+*
+* `appDir` and `routeDir` must be forward-slash — `currentDir` descends from
+* `appDir` via `path.posix.join`, and the `dir === routeDir` active-level test
+* below only matches when both share the canonical separator.
 */
 function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher) {
 	const slotMap = /* @__PURE__ */ new Map();
@@ -875,7 +910,7 @@ function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher) {
 		segmentIndex: 0
 	});
 	for (let i = 0; i < segments.length; i++) {
-		currentDir = path.join(currentDir, segments[i]);
+		currentDir = path.posix.join(currentDir, segments[i]);
 		if (findFile(currentDir, "layout", matcher)) layoutIdx++;
 		dirsToCheck.push({
 			dir: currentDir,
@@ -902,9 +937,12 @@ function discoverInheritedParallelSlots(segments, appDir, routeDir, matcher) {
 				slotPatternParts = [...ownerUrl?.urlSegments ?? [], ...mirror.slotUrlSegments];
 				slotParamNames = [...ownerUrl?.params ?? [], ...mirror.slotParamNames];
 			}
+			const configLayoutPaths = findSlotConfigLayoutPaths(slot.ownerDir, mirror?.pagePath ?? null, matcher);
 			const inheritedSlot = {
 				...slot,
 				pagePath: mirror?.pagePath ?? null,
+				configLayoutPaths,
+				configLayoutTreePositions: findSlotConfigLayoutTreePositions(slot.ownerDir, configLayoutPaths),
 				layoutIndex: slotLayoutIdx,
 				routeSegments: mirror?.segments ?? null,
 				slotPatternParts,
@@ -1035,6 +1073,9 @@ function patternsStructurallyEquivalent(a, b) {
 *
 * Returns the absolute page path, or null if no root-level page is found.
 *
+* `slotDir` must be forward-slash: the `path.posix.join` descent stays a
+* canonical id only when the base already is.
+*
 * Only descends into route-group directories (those whose name starts with `(`
 * and ends with `)`). Dynamic segments, regular named dirs, and `@slot` dirs
 * are not transparent and are therefore not searched.
@@ -1051,7 +1092,7 @@ function findSlotRootPage(slotDir, matcher) {
 	for (const entry of entries) {
 		if (!entry.isDirectory()) continue;
 		if (!entry.name.startsWith("(") || !entry.name.endsWith(")")) continue;
-		const found = findSlotRootPage(path.join(slotDir, entry.name), matcher);
+		const found = findSlotRootPage(path.posix.join(slotDir, entry.name), matcher);
 		if (found) return found;
 	}
 	return null;
@@ -1068,13 +1109,14 @@ function discoverParallelSlots(dir, appDir, matcher) {
 		if (!entry.isDirectory() || !entry.name.startsWith("@")) continue;
 		if (entry.name === "@children") continue;
 		const slotName = entry.name.slice(1);
-		const slotDir = path.join(dir, entry.name);
+		const slotDir = path.posix.join(dir, entry.name);
 		const pagePath = findSlotRootPage(slotDir, matcher);
 		const defaultPath = findFile(slotDir, "default", matcher);
 		const interceptingRoutes = discoverInterceptingRoutes(slotDir, dir, appDir, matcher);
 		if (!pagePath && !defaultPath && interceptingRoutes.length === 0) continue;
 		const ownerSegments = path.relative(appDir, dir).split(path.sep).filter((segment) => segment.length > 0);
 		const ownerTreePath = createAppRouteGraphTreePath(ownerSegments, ownerSegments.length);
+		const configLayoutPaths = findSlotConfigLayoutPaths(slotDir, pagePath, matcher);
 		slots.push({
 			id: createAppRouteGraphSlotId(slotName, ownerTreePath),
 			key: `${slotName}@${path.relative(appDir, slotDir).replace(/\\/g, "/")}`,
@@ -1085,6 +1127,8 @@ function discoverParallelSlots(dir, appDir, matcher) {
 			pagePath,
 			defaultPath,
 			layoutPath: findFile(slotDir, "layout", matcher),
+			configLayoutPaths,
+			configLayoutTreePositions: findSlotConfigLayoutTreePositions(slotDir, configLayoutPaths),
 			loadingPath: findFile(slotDir, "loading", matcher),
 			errorPath: findFile(slotDir, "error", matcher),
 			interceptingRoutes,
@@ -1272,8 +1316,12 @@ function collectInterceptingPages(currentDir, interceptRoot, convention, interce
 		if (targetPattern) {
 			const sourceMatchPattern = computeInterceptSourceMatchPattern(interceptParentDir, appDir);
 			results.push({
+				branchSegments: [interceptSegment, ...normalizePathSeparators(path.relative(interceptRoot, path.dirname(page))).split("/").filter(Boolean)],
 				convention,
 				layoutPaths: [...layoutPaths],
+				layoutSegments: layoutPaths.map((layoutPath) => {
+					return [interceptSegment, ...path.relative(interceptRoot, path.dirname(layoutPath)).split(path.sep).filter(Boolean)];
+				}),
 				targetPattern: targetPattern.pattern,
 				sourceMatchPattern,
 				pagePath: page,

package/dist/routing/app-router.d.ts

@@ -12,11 +12,16 @@ declare function invalidateAppRouteCache(): void;
  * TODO(#726): Layer 4 should consume this read model directly once the
  * navigation planner owns route graph facts.
  *
+ * `appDir` must be forward-slash — callers normalize it at their entry, and it
+ * flows into `buildAppRouteGraph`, which builds every path with `path.posix.*`.
+ *
  * @internal
  */
 declare function appRouteGraph(appDir: string, pageExtensions?: readonly string[], matcher?: ValidFileMatcher): Promise<AppRouteGraph>;
 /**
  * Scan the app/ directory and return a list of routes.
+ *
+ * `appDir` must be forward-slash — it is forwarded to `appRouteGraph`.
  */
 declare function appRouter(appDir: string, pageExtensions?: readonly string[], matcher?: ValidFileMatcher): Promise<AppRouteGraphRoute[]>;
 /**

package/dist/routing/app-router.js

@@ -30,6 +30,9 @@ function invalidateAppRouteCache() {
 * TODO(#726): Layer 4 should consume this read model directly once the
 * navigation planner owns route graph facts.
 *
+* `appDir` must be forward-slash — callers normalize it at their entry, and it
+* flows into `buildAppRouteGraph`, which builds every path with `path.posix.*`.
+*
 * @internal
 */
 async function appRouteGraph(appDir, pageExtensions, matcher) {
@@ -44,6 +47,8 @@ async function appRouteGraph(appDir, pageExtensions, matcher) {
 }
 /**
 * Scan the app/ directory and return a list of routes.
+*
+* `appDir` must be forward-slash — it is forwarded to `appRouteGraph`.
 */
 async function appRouter(appDir, pageExtensions, matcher) {
 	return (await appRouteGraph(appDir, pageExtensions, matcher)).routes;

package/dist/routing/file-matcher.d.ts

@@ -54,6 +54,11 @@ declare function buildViteResolveExtensions(pageExtensions?: readonly string[] |
 declare function normalizeViteResolveExtensions(extensions: readonly string[]): string[];
 /**
  * Use function-form exclude for Node < 22.14 compatibility.
+ *
+ * Yields forward-slash relative paths: node's glob emits native (backslash)
+ * separators on Windows, so each match is normalized — this is the entry point
+ * that lets downstream consumers treat the scanned paths as canonical
+ * forward-slash ids.
  */
 declare function scanWithExtensions(stem: string, cwd: string, extensions: readonly string[], exclude?: (name: string) => boolean): AsyncGenerator<string>;
 //#endregion

package/dist/routing/file-matcher.js

@@ -1,3 +1,4 @@
+import { normalizePathSeparators } from "../utils/path.js";
 import { escapeRegExp } from "../utils/regex.js";
 import { existsSync } from "node:fs";
 import path from "node:path";
@@ -135,13 +136,18 @@ function normalizeViteResolveExtensions(extensions) {
 }
 /**
 * Use function-form exclude for Node < 22.14 compatibility.
+*
+* Yields forward-slash relative paths: node's glob emits native (backslash)
+* separators on Windows, so each match is normalized — this is the entry point
+* that lets downstream consumers treat the scanned paths as canonical
+* forward-slash ids.
 */
 async function* scanWithExtensions(stem, cwd, extensions, exclude) {
 	const pattern = buildExtensionGlob(stem, extensions);
 	for await (const file of glob(pattern, {
 		cwd,
 		...exclude ? { exclude } : {}
-	})) yield file;
+	})) yield normalizePathSeparators(file);
 }
 //#endregion
 export { buildViteResolveExtensions, createValidFileMatcher, findFileWithExtensions, findFileWithExts, normalizePageExtensions, normalizeViteResolveExtensions, scanWithExtensions };

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-fallback-renderer.d.ts

@@ -75,7 +75,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

@@ -97,7 +97,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 +108,7 @@ function createAppFallbackRenderer(options) {
 					return buildRscOnErrorHandler(request, pathname, routePath);
 				},
 				error,
+				errorOrigin,
 				getFontLinks: fontProviders.getFontLinks,
 				getFontPreloads: fontProviders.getFontPreloads,
 				getFontStyles: fontProviders.getFontStyles,

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);

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;

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

@@ -3,7 +3,7 @@ import { getRequestExecutionContext } from "../shims/request-context.js";
 import { AppElementsWire } from "./app-elements-wire.js";
 import { shouldSuppressLoadingBoundaries } from "./app-rsc-render-mode.js";
 import "./app-elements.js";
-import { consumeDynamicUsage, consumeInvalidDynamicUsageError, getAndClearPendingCookies, getDraftModeCookieHeader, isDraftModeRequest, markDynamicUsage, peekRenderRequestApiUsage, setHeadersContext } from "../shims/headers.js";
+import { consumeDynamicUsage, consumeInvalidDynamicUsageError, getAndClearPendingCookies, getDraftModeCookieHeader, getHeadersContext, isDraftModeRequest, markDynamicUsage, peekDynamicUsage, peekRenderRequestApiUsage, setHeadersContext } from "../shims/headers.js";
 import { _consumeRequestScopedCacheLife, _peekRequestScopedCacheLife } from "../shims/cache-request-state.js";
 import { ensureFetchPatch, getCollectedFetchTags, peekDynamicFetchObservations, runWithFetchDedupe, setCurrentFetchCacheMode, setCurrentFetchSoftTags, setCurrentForceDynamicFetchDefault } from "../shims/fetch-cache.js";
 import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
@@ -107,6 +107,7 @@ async function runAppPageRevalidationContext(options, renderFn) {
 	const { createStaticGenerationHeadersContext } = await import("./app-static-generation.js");
 	return runWithRequestContext(createRequestContext({
 		headersContext: createStaticGenerationHeadersContext({
+			draftModeEnabled: false,
 			draftModeSecret: options.draftModeSecret,
 			dynamicConfig: options.dynamicConfig,
 			routeKind: "page",
@@ -131,6 +132,8 @@ function toInterceptOptions(interceptionContext, intercept) {
 	return {
 		interceptionContext,
 		interceptLayouts: intercept.interceptLayouts,
+		interceptLayoutSegments: intercept.interceptLayoutSegments,
+		interceptBranchSegments: intercept.interceptBranchSegments,
 		interceptPage: intercept.page,
 		interceptParams: intercept.matchedParams,
 		interceptSlotId: intercept.slotId ?? null,
@@ -152,7 +155,11 @@ async function dispatchAppPageInner(options) {
 	const isDynamicError = dynamicConfig === "error";
 	const isForceDynamic = dynamicConfig === "force-dynamic";
 	const isDraftMode = isDraftModeRequest(options.request, options.draftModeSecret);
+	const requestHeadersContext = getHeadersContext();
+	const hasRequestSearchParams = !isForceStatic && hasSearchParams(options.searchParams);
+	const pageSearchParams = isForceStatic ? new URLSearchParams() : options.searchParams;
 	const layoutParamAccess = createAppLayoutParamAccessTracker();
+	const hasActiveLoadingBoundary = shouldSuppressLoadingBoundaries(options.renderMode ?? "navigation") ? false : Boolean(route.loading?.default);
 	setCurrentFetchSoftTags(buildAppPageTags(options.cleanPathname, [], route.routeSegments));
 	setCurrentFetchCacheMode(options.fetchCache ?? null);
 	setCurrentForceDynamicFetchDefault(isForceDynamic);
@@ -172,9 +179,10 @@ async function dispatchAppPageInner(options) {
 		options.clearRequestContext();
 		return methodResponse;
 	}
-	if ((isForceStatic || isDynamicError) && !isDraftMode) {
+	if (isForceStatic || isDynamicError) {
 		const { createStaticGenerationHeadersContext } = await import("./app-static-generation.js");
 		setHeadersContext(createStaticGenerationHeadersContext({
+			draftModeEnabled: isDraftMode,
 			draftModeSecret: options.draftModeSecret,
 			dynamicConfig,
 			routeKind: "page",
@@ -200,7 +208,7 @@ async function dispatchAppPageInner(options) {
 		const cachedPageResponse = await readAppPageCacheResponse({
 			cleanPathname: options.cleanPathname,
 			clearRequestContext: options.clearRequestContext,
-			hasRequestSearchParams: !isForceStatic && hasSearchParams(options.searchParams),
+			hasRequestSearchParams,
 			isEdgeRuntime: options.isEdgeRuntime,
 			isRscRequest: options.isRscRequest,
 			isrDebug: options.isrDebug,
@@ -234,19 +242,23 @@ async function dispatchAppPageInner(options) {
 				});
 				revalidationTarget.navigationParams = resolveAppPageNavigationParams(revalidationTarget.route, revalidationTarget.navigationParams, options.cleanPathname, revalidationTarget.interceptOpts);
 				await options.ensureRouteLoaded?.(revalidationTarget.route);
+				const revalidationDynamicConfig = options.resolveRouteDynamicConfig?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? dynamicConfig : void 0);
 				return runAppPageRevalidationContext({
 					cleanPathname: options.cleanPathname,
 					displayPathname: options.displayPathname,
 					currentFetchCacheMode: options.resolveRouteFetchCacheMode?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? options.fetchCache ?? null : null),
 					draftModeSecret: options.draftModeSecret,
-					dynamicConfig: options.resolveRouteDynamicConfig?.(revalidationTarget.route) ?? (revalidationTarget.route === route ? dynamicConfig : void 0),
+					dynamicConfig: revalidationDynamicConfig,
 					params: revalidationTarget.navigationParams,
 					routePattern: revalidationTarget.route.pattern,
 					routeSegments: revalidationTarget.route.routeSegments,
 					setNavigationContext: options.setNavigationContext
 				}, async () => {
 					const { renderAppPageCacheArtifacts } = await import("./app-page-cache-render.js");
-					const revalidatedElement = await options.buildPageElement(revalidationTarget.route, revalidationTarget.params, revalidationTarget.interceptOpts, new URLSearchParams());
+					const revalidatedElement = await options.buildPageElement(revalidationTarget.route, revalidationTarget.params, revalidationTarget.interceptOpts, new URLSearchParams(), void 0, {
+						observeMetadataSearchParamsAccess: revalidationDynamicConfig !== "force-static",
+						observePageSearchParamsAccess: revalidationDynamicConfig !== "force-static"
+					});
 					const revalidatedOnError = options.createRscOnErrorHandler(options.cleanPathname, revalidationTarget.route.pattern);
 					const rendered = await renderAppPageCacheArtifacts({
 						basePath: options.basePath,
@@ -301,12 +313,27 @@ async function dispatchAppPageInner(options) {
 	}
 	const fallbackShellResponse = options.pprRuntime ? await options.pprRuntime.tryServe(options, currentRevalidateSeconds, isDraftMode, isForceStatic, isForceDynamic) : null;
 	if (fallbackShellResponse) return fallbackShellResponse;
+	let interceptDynamicConfig;
+	let interceptDynamicConfigResolved = false;
 	const interceptResult = await resolveAppPageIntercept({
 		async buildPageElement(interceptRoute, interceptParams, interceptOpts, interceptSearchParams, interceptLayoutParamAccess) {
-			await options.ensureRouteLoaded?.(interceptRoute);
+			const sourceDynamicConfig = interceptDynamicConfigResolved ? interceptDynamicConfig : options.resolveRouteDynamicConfig?.(interceptRoute);
+			if (sourceDynamicConfig === "force-static" || sourceDynamicConfig === "error") {
+				const { createStaticGenerationHeadersContext } = await import("./app-static-generation.js");
+				setHeadersContext(createStaticGenerationHeadersContext({
+					draftModeEnabled: isDraftMode,
+					draftModeSecret: options.draftModeSecret,
+					dynamicConfig: sourceDynamicConfig,
+					routeKind: "page",
+					routePattern: interceptRoute.pattern
+				}));
+			} else setHeadersContext(requestHeadersContext);
 			setCurrentFetchCacheMode(options.resolveRouteFetchCacheMode?.(interceptRoute) ?? null);
-			setCurrentForceDynamicFetchDefault(options.resolveRouteDynamicConfig?.(interceptRoute) === "force-dynamic");
-			return options.buildPageElement(interceptRoute, interceptParams, interceptOpts, interceptSearchParams, interceptLayoutParamAccess);
+			setCurrentForceDynamicFetchDefault(sourceDynamicConfig === "force-dynamic");
+			return options.buildPageElement(interceptRoute, interceptParams, interceptOpts, interceptSearchParams, interceptLayoutParamAccess, {
+				observeMetadataSearchParamsAccess: sourceDynamicConfig !== "force-static",
+				observePageSearchParamsAccess: sourceDynamicConfig !== "force-static"
+			});
 		},
 		cleanPathname: options.cleanPathname,
 		currentRoute: route,
@@ -338,6 +365,12 @@ async function dispatchAppPageInner(options) {
 				headers: interceptHeaders
 			});
 		},
+		async resolveSearchParams(sourceRoute, searchParams) {
+			await options.ensureRouteLoaded?.(sourceRoute);
+			interceptDynamicConfig = options.resolveRouteDynamicConfig?.(sourceRoute);
+			interceptDynamicConfigResolved = true;
+			return interceptDynamicConfig === "force-static" ? new URLSearchParams() : searchParams;
+		},
 		searchParams: options.searchParams,
 		setNavigationContext: options.setNavigationContext,
 		toInterceptOpts(intercept) {
@@ -348,12 +381,15 @@ async function dispatchAppPageInner(options) {
 	const buildCurrentPageElement = () => buildAppPageElement({
 		buildPageElement() {
 			if (options.actionFailed) throw options.actionError;
-			return options.buildPageElement(route, options.params, interceptResult.interceptOpts, options.searchParams, layoutParamAccess);
+			return options.buildPageElement(route, options.params, interceptResult.interceptOpts, pageSearchParams, layoutParamAccess, {
+				observeMetadataSearchParamsAccess: !isForceStatic,
+				observePageSearchParamsAccess: !isForceStatic
+			});
 		},
 		async probePageSpecialError() {
 			if (!shouldSuppressLoadingBoundaries(options.renderMode ?? "navigation") && route.loading?.default) return null;
 			return resolveAppPageSpecialError(await probeAppPageThrownError({
-				probePage: options.probePage,
+				probePage: () => options.probePage(pageSearchParams),
 				runWithSuppressedHookWarning(probe) {
 					return options.runWithSuppressedHookWarning(probe);
 				}
@@ -384,7 +420,7 @@ async function dispatchAppPageInner(options) {
 	const navigationParams = resolveAppPageNavigationParams(route, options.params, options.cleanPathname, interceptResult.interceptOpts);
 	options.setNavigationContext({
 		pathname: options.displayPathname ?? options.cleanPathname,
-		searchParams: options.searchParams,
+		searchParams: pageSearchParams,
 		params: navigationParams
 	});
 	const layoutClassifications = getEffectiveLayoutClassifications(route, options.debugClassification);
@@ -398,6 +434,7 @@ async function dispatchAppPageInner(options) {
 		cleanPathname: options.cleanPathname,
 		clearRequestContext: options.clearRequestContext,
 		consumeDynamicUsage,
+		peekDynamicUsage,
 		consumeInvalidDynamicUsageError,
 		consumeRenderObservationState: consumeAppPageRenderObservationState,
 		createRscOnErrorHandler(pathname, routePath) {
@@ -420,7 +457,8 @@ async function dispatchAppPageInner(options) {
 			return _peekRequestScopedCacheLife();
 		},
 		handlerStart: options.handlerStart,
-		hasLoadingBoundary: shouldSuppressLoadingBoundaries(options.renderMode ?? "navigation") ? false : Boolean(route.loading?.default),
+		hasLoadingBoundary: hasActiveLoadingBoundary,
+		omitPendingDynamicCacheState: !options.isRscRequest && hasRequestSearchParams,
 		formState: options.formState ?? null,
 		isProgressiveActionRender: options.isProgressiveActionRender === true,
 		isDynamicError,
@@ -459,8 +497,9 @@ async function dispatchAppPageInner(options) {
 			return options.probeLayoutAt(layoutIndex, layoutParamAccess);
 		},
 		probePage() {
-			return options.probePage();
+			return options.probePage(pageSearchParams);
 		},
+		probePageBeforeRender: options.isRscRequest,
 		classification: {
 			getLayoutId(index) {
 				const treePosition = route.layoutTreePositions?.[index] ?? 0;
@@ -489,8 +528,8 @@ async function dispatchAppPageInner(options) {
 		revalidateSeconds: currentRevalidateSeconds,
 		mountedSlotsHeader: options.mountedSlotsHeader,
 		renderMode: options.renderMode ?? "navigation",
-		renderErrorBoundaryResponse(renderError) {
-			return options.renderErrorBoundaryPage(renderError);
+		renderErrorBoundaryResponse(renderError, errorOrigin) {
+			return options.renderErrorBoundaryPage(renderError, errorOrigin);
 		},
 		renderLayoutSpecialError(specialError, layoutIndex) {
 			return renderLayoutSpecialError(options, specialError, layoutIndex);