@qzsy/vinext 0.1.12 → 0.1.80

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

@@ -248,8 +248,11 @@ function wrapRscResponseForDevErrorReporting(response, consumeInvalidDynamicUsag
 	});
 }
 async function renderAppPageLifecycle(options) {
+	const configuredProbePageBeforeRender = options.probePageBeforeRender ?? options.isRscRequest;
+	const probePageBeforeRender = options.isRscRequest || configuredProbePageBeforeRender && !(options.peekDynamicUsage?.() ?? false);
 	const preRenderResult = await probeAppPageBeforeRender({
 		hasLoadingBoundary: options.hasLoadingBoundary,
+		probePageBeforeRender,
 		skipProbes: options.pprFallbackShellSignal !== void 0,
 		layoutCount: options.layoutCount,
 		probeLayoutAt(layoutIndex) {
@@ -430,7 +433,8 @@ async function renderAppPageLifecycle(options) {
 			if (!options.isProduction) renderEnd = performance.now();
 		},
 		renderErrorBoundaryResponse(error) {
-			return options.renderErrorBoundaryResponse(rscErrorTracker.getCapturedError() ?? error);
+			const capturedRscError = rscErrorTracker.getCapturedError();
+			return options.renderErrorBoundaryResponse(capturedRscError ?? error, capturedRscError === null ? "ssr" : "rsc");
 		},
 		async renderHtmlStream() {
 			const ssrHandler = await options.loadSsrHandler();
@@ -462,7 +466,7 @@ async function renderAppPageLifecycle(options) {
 	if (!htmlStream) throw new Error("[vinext] Expected an HTML stream when no fallback response was returned");
 	const linkHeader = buildAppPageLinkHeader(htmlRender.linkHeader, fontLinkHeader, options.reactMaxHeadersLength);
 	if (options.isPrerender === true) await htmlRender.metadataReady;
-	if (options.hasLoadingBoundary) {
+	if (options.hasLoadingBoundary || !probePageBeforeRender) {
 		const captured = rscErrorTracker.getCapturedSpecialError();
 		if (captured) {
 			const specialError = resolveAppPageSpecialError(captured);
@@ -480,8 +484,8 @@ async function renderAppPageLifecycle(options) {
 			revalidateSeconds
 		}));
 	}
+	let dynamicUsedDuringRender = options.consumeDynamicUsage();
 	const draftCookie = options.getDraftModeCookieHeader();
-	const dynamicUsedDuringRender = options.consumeDynamicUsage();
 	let dynamicUsedBeforeContextCleanup = dynamicUsedDuringRender;
 	const safeHtmlStream = deferUntilStreamConsumed(htmlStream, () => {
 		dynamicUsedBeforeContextCleanup = dynamicUsedBeforeContextCleanup || options.consumeDynamicUsage();
@@ -575,6 +579,7 @@ async function renderAppPageLifecycle(options) {
 			isrRscKey: options.isrRscKey,
 			isrSet: options.isrSet,
 			interceptionContext: options.interceptionContext,
+			omitPendingDynamicCacheState: options.omitPendingDynamicCacheState,
 			preserveClientResponseHeaders: !htmlResponsePolicy.shouldWriteToCache,
 			expireSeconds,
 			revalidateSeconds,

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

@@ -12,8 +12,20 @@ type GenerateStaticParamsModule = {
 };
 type GenerateStaticParamsSource = {
   generateStaticParams: GenerateStaticParams;
+  paramAliases?: Readonly<Record<string, string>>;
+  paramPatternParts?: readonly string[];
+  routePatternParts?: readonly string[];
   parentParamNames: readonly string[];
 };
+type ParallelGenerateStaticParamsBranch = {
+  configLayouts?: readonly (GenerateStaticParamsModule | null | undefined)[] | null;
+  configLayoutTreePositions?: readonly number[] | null;
+  layout?: GenerateStaticParamsModule | null;
+  page?: GenerateStaticParamsModule | null;
+  paramNames?: readonly string[] | null;
+  patternParts?: readonly string[] | null;
+  routeSegments?: readonly string[] | null;
+};
 type ValidateAppPageDynamicParamsOptions = {
   clearRequestContext: () => void;
   enforceStaticParamsOnly: boolean;
@@ -25,6 +37,8 @@ type ResolveAppPageGenerateStaticParamsSourcesOptions = {
   layouts?: readonly (GenerateStaticParamsModule | null | undefined)[];
   layoutTreePositions?: readonly number[];
   page?: GenerateStaticParamsModule | null;
+  parallelBranches?: readonly (ParallelGenerateStaticParamsBranch | null | undefined)[];
+  routePatternParts?: readonly string[];
   routeSegments: readonly string[];
 };
 type BuildAppPageElementOptions<TElement> = {
@@ -40,8 +54,11 @@ type BuildAppPageElementResult<TElement> = {
 };
 type AppPageInterceptMatch<TPage = unknown> = {
   interceptLayouts?: readonly unknown[] | null;
+  interceptLayoutSegments?: readonly (readonly string[])[] | null;
+  interceptBranchSegments?: readonly string[] | null;
   __loadInterceptLayouts?: readonly (() => Promise<unknown>)[] | null;
   matchedParams: AppPageParams;
+  sourceMatchedParams?: AppPageParams;
   page: TPage;
   __pageLoader?: (() => Promise<TPage>) | null;
   __loadState?: {
@@ -88,7 +105,10 @@ type ResolveAppPageInterceptionRerenderTargetResult<TRoute, TInterceptOpts> = {
 type ResolveAppPageActionRerenderTargetOptions<TRoute, TPage, TInterceptOpts> = ResolveAppPageInterceptionRerenderTargetOptions<TRoute, TPage, TInterceptOpts>;
 type ResolveAppPageActionRerenderTargetResult<TRoute, TInterceptOpts> = ResolveAppPageInterceptionRerenderTargetResult<TRoute, TInterceptOpts>;
 type ResolveAppPageInterceptOptions<TRoute, TPage, TInterceptOpts, TElement> = {
-  buildPageElement: (route: TRoute, params: AppPageParams, interceptOpts: TInterceptOpts | undefined, searchParams: URLSearchParams, layoutParamAccess?: AppLayoutParamAccessTracker) => Promise<TElement>;
+  buildPageElement: (route: TRoute, params: AppPageParams, interceptOpts: TInterceptOpts | undefined, searchParams: URLSearchParams, layoutParamAccess?: AppLayoutParamAccessTracker, buildOptions?: {
+    observeMetadataSearchParamsAccess?: boolean;
+    observePageSearchParamsAccess?: boolean;
+  }) => Promise<TElement>;
   cleanPathname: string;
   currentRoute: TRoute;
   findIntercept: (pathname: string) => AppPageInterceptMatch<TPage> | null;
@@ -98,6 +118,7 @@ type ResolveAppPageInterceptOptions<TRoute, TPage, TInterceptOpts, TElement> = {
   layoutParamAccess?: AppLayoutParamAccessTracker;
   resolveNavigationParams: (route: TRoute, params: AppPageParams, pathname: string, interceptOpts: TInterceptOpts) => AppPageParams;
   renderInterceptResponse: (route: TRoute, element: TElement) => Promise<Response> | Response;
+  resolveSearchParams?: (route: TRoute, searchParams: URLSearchParams) => Awaitable<URLSearchParams>;
   searchParams: URLSearchParams;
   setNavigationContext: (context: {
     params: AppPageParams;

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

@@ -1,5 +1,6 @@
 import { notFoundResponse } from "./http-error-responses.js";
 import { runWithFetchDedupe } from "../shims/fetch-cache.js";
+import { matchRoutePattern } from "../routing/route-pattern.js";
 import { getAppPageSegmentParamName } from "./app-page-params.js";
 import { loadAppInterceptLayouts } from "./app-route-module-loader.js";
 //#region src/server/app-page-request.ts
@@ -11,6 +12,31 @@ function pickRouteParams(matchedParams, routeParamNames) {
 	}
 	return params;
 }
+function remapRouteParams(matchedParams, source) {
+	if (source.paramPatternParts && source.routePatternParts) {
+		const urlParts = [];
+		for (const part of source.routePatternParts) {
+			if (!part.startsWith(":")) {
+				urlParts.push(part);
+				continue;
+			}
+			const value = matchedParams[part.slice(1).replace(/[+*]$/, "")];
+			if (Array.isArray(value)) urlParts.push(...value.map(encodeURIComponent));
+			else if (value !== void 0) urlParts.push(encodeURIComponent(value));
+		}
+		const slotParams = matchRoutePattern(urlParts, source.paramPatternParts);
+		if (slotParams) return slotParams;
+	}
+	if (!source.paramAliases) return matchedParams;
+	const params = { ...matchedParams };
+	for (const [routeParamName, sourceParamName] of Object.entries(source.paramAliases)) {
+		const value = matchedParams[routeParamName];
+		if (value === void 0) continue;
+		delete params[routeParamName];
+		params[sourceParamName] = value;
+	}
+	return params;
+}
 function collectParentParamNames(routeSegments, boundaryPosition) {
 	const limit = Math.max(0, Math.min(boundaryPosition, routeSegments.length));
 	const names = [];
@@ -23,6 +49,16 @@ function collectParentParamNames(routeSegments, boundaryPosition) {
 function getLayoutGenerateStaticParamsBoundary(layoutTreePosition) {
 	return (layoutTreePosition ?? 0) - 1;
 }
+function getParallelParentParamNames(routeParamNames, branch, boundaryPosition) {
+	const slotParamNames = branch.paramNames ?? routeParamNames;
+	const branchParamNames = collectParentParamNames(branch.routeSegments ?? [], boundaryPosition);
+	const branchParamNameSet = new Set((branch.routeSegments ?? []).flatMap((segment) => {
+		const name = getAppPageSegmentParamName(segment);
+		return name ? [name] : [];
+	}));
+	const ownerParamNames = slotParamNames.filter((name) => !branchParamNameSet.has(name));
+	return [...new Set([...ownerParamNames, ...branchParamNames])];
+}
 function resolveAppPageGenerateStaticParamsSources(options) {
 	const sources = [];
 	options.layouts?.forEach((layout, index) => {
@@ -36,6 +72,33 @@ function resolveAppPageGenerateStaticParamsSources(options) {
 		generateStaticParams: options.page.generateStaticParams,
 		parentParamNames: collectParentParamNames(options.routeSegments, Math.max(0, options.routeSegments.length - 1))
 	});
+	const routeParamNames = options.routeSegments.flatMap((segment) => {
+		const name = getAppPageSegmentParamName(segment);
+		return name ? [name] : [];
+	});
+	for (const parallelBranch of options.parallelBranches ?? []) {
+		if (!parallelBranch) continue;
+		const slotParamNames = parallelBranch.paramNames ?? routeParamNames;
+		const paramAliases = Object.fromEntries(routeParamNames.flatMap((routeParamName, index) => {
+			const slotParamName = slotParamNames[index];
+			return slotParamName && slotParamName !== routeParamName ? [[routeParamName, slotParamName]] : [];
+		}));
+		const addParallelSource = (module, boundaryPosition) => {
+			if (typeof module?.generateStaticParams !== "function") return;
+			sources.push({
+				generateStaticParams: module.generateStaticParams,
+				...Object.keys(paramAliases).length > 0 ? { paramAliases } : {},
+				...parallelBranch.patternParts ? { paramPatternParts: parallelBranch.patternParts } : {},
+				...options.routePatternParts ? { routePatternParts: options.routePatternParts } : {},
+				parentParamNames: getParallelParentParamNames(routeParamNames, parallelBranch, boundaryPosition)
+			});
+		};
+		addParallelSource(parallelBranch.layout, -1);
+		parallelBranch.configLayouts?.forEach((layout, index) => {
+			addParallelSource(layout, getLayoutGenerateStaticParamsBoundary(parallelBranch.configLayoutTreePositions?.[index]));
+		});
+		addParallelSource(parallelBranch.page, Math.max(0, (parallelBranch.routeSegments?.length ?? 0) - 1));
+	}
 	return sources;
 }
 function areStaticParamsAllowed(params, staticParams) {
@@ -67,8 +130,9 @@ async function validateAppPageDynamicParams(options) {
 		return notFoundResponse();
 	}
 	for (const source of generateStaticParamsSources) {
-		const staticParams = await runWithFetchDedupe(() => source.generateStaticParams({ params: pickRouteParams(options.params, source.parentParamNames) }));
-		if (Array.isArray(staticParams) && !areStaticParamsAllowed(options.params, staticParams)) {
+		const sourceParams = remapRouteParams(options.params, source);
+		const staticParams = await runWithFetchDedupe(() => source.generateStaticParams({ params: pickRouteParams(sourceParams, source.parentParamNames) }));
+		if (Array.isArray(staticParams) && !areStaticParamsAllowed(sourceParams, staticParams)) {
 			options.clearRequestContext();
 			return notFoundResponse();
 		}
@@ -97,7 +161,7 @@ async function resolveAppPageInterceptMatch(options) {
 	return {
 		interceptOpts: options.toInterceptOpts(interceptState.intercept),
 		matchedParams: interceptState.intercept.matchedParams,
-		sourceParams: pickRouteParams(interceptState.intercept.matchedParams, options.getRouteParamNames(interceptState.sourceRoute)),
+		sourceParams: pickRouteParams(interceptState.intercept.sourceMatchedParams ?? interceptState.intercept.matchedParams, options.getRouteParamNames(interceptState.sourceRoute)),
 		sourceRoute: interceptState.sourceRoute
 	};
 }
@@ -145,12 +209,18 @@ async function resolveAppPageInterceptionRerenderTarget(options) {
 		isRscRequest: options.isRscRequest,
 		toInterceptOpts: options.toInterceptOpts
 	});
-	if (interceptState.kind === "source-route") return {
-		interceptOpts: options.toInterceptOpts(interceptState.intercept),
-		navigationParams: interceptState.intercept.matchedParams,
-		params: pickRouteParams(interceptState.intercept.matchedParams, options.getRouteParamNames(interceptState.sourceRoute)),
-		route: interceptState.sourceRoute
-	};
+	if (interceptState.kind === "source-route") {
+		const sourceMatchedParams = interceptState.intercept.sourceMatchedParams ?? interceptState.intercept.matchedParams;
+		return {
+			interceptOpts: options.toInterceptOpts(interceptState.intercept),
+			navigationParams: {
+				...sourceMatchedParams,
+				...interceptState.intercept.matchedParams
+			},
+			params: pickRouteParams(sourceMatchedParams, options.getRouteParamNames(interceptState.sourceRoute)),
+			route: interceptState.sourceRoute
+		};
+	}
 	return {
 		interceptOpts: interceptState.kind === "current-route" ? options.toInterceptOpts(interceptState.intercept) : void 0,
 		navigationParams: options.currentParams,
@@ -174,13 +244,19 @@ async function resolveAppPageIntercept(options) {
 	if (interceptState.kind === "source-route") {
 		const renderRoute = interceptState.sourceRoute;
 		const interceptOpts = options.toInterceptOpts(interceptState.intercept);
-		const renderParams = pickRouteParams(interceptState.intercept.matchedParams, options.getRouteParamNames(interceptState.sourceRoute));
+		const sourceMatchedParams = interceptState.intercept.sourceMatchedParams ?? interceptState.intercept.matchedParams;
+		const navigationParams = {
+			...sourceMatchedParams,
+			...interceptState.intercept.matchedParams
+		};
+		const renderSearchParams = options.resolveSearchParams ? await options.resolveSearchParams(renderRoute, options.searchParams) : options.searchParams;
+		const renderParams = pickRouteParams(sourceMatchedParams, options.getRouteParamNames(interceptState.sourceRoute));
 		options.setNavigationContext({
-			params: options.resolveNavigationParams(renderRoute, interceptState.intercept.matchedParams, options.cleanPathname, interceptOpts),
+			params: options.resolveNavigationParams(renderRoute, navigationParams, options.cleanPathname, interceptOpts),
 			pathname: options.cleanPathname,
-			searchParams: options.searchParams
+			searchParams: renderSearchParams
 		});
-		const interceptElement = await options.buildPageElement(renderRoute, renderParams, interceptOpts, options.searchParams, options.layoutParamAccess);
+		const interceptElement = await options.buildPageElement(renderRoute, renderParams, interceptOpts, renderSearchParams, options.layoutParamAccess);
 		return {
 			interceptOpts: void 0,
 			response: await options.renderInterceptResponse(renderRoute, interceptElement)

package/dist/server/app-page-route-wiring.d.ts

@@ -1,8 +1,8 @@
 import { AppRouteSemanticIds } from "../routing/app-route-graph.js";
 import { AppElements, AppElementsInterception } from "./app-elements-wire.js";
 import { AppPageParams } from "./app-page-boundary.js";
-import { Metadata, Viewport } from "../shims/metadata.js";
 import { ThenableParamsObserver } from "../shims/thenable-params.js";
+import { Metadata, Viewport } from "../shims/metadata.js";
 import { AppLayoutParamAccessTracker } from "./app-layout-param-observation.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { AppPageRenderIdentity } from "./app-page-render-identity.js";
@@ -31,6 +31,8 @@ type AppPageRouteWiringSlot<TModule extends AppPageModule = AppPageModule, TErro
   /** Graph-owned semantic slot identity. */id?: string | null; /** Slot prop name passed to the owning layout (e.g. "modal" from @modal). */
   name: string;
   default?: TModule | null;
+  configLayouts?: readonly (TModule | null | undefined)[] | null;
+  configLayoutTreePositions?: readonly number[] | null;
   error?: TErrorModule | null;
   layout?: TModule | null;
   layoutIndex: number;
@@ -83,6 +85,8 @@ type AppPageRouteWiringRoute<TModule extends AppPageModule = AppPageModule, TErr
   templates?: readonly (TModule | null | undefined)[] | null;
 };
 type AppPageSlotOverride<TModule extends AppPageModule = AppPageModule> = {
+  branchSegments?: readonly string[] | null;
+  layoutSegments?: readonly (readonly string[])[] | null;
   layoutModules?: readonly (TModule | null | undefined)[] | null;
   /**
    * The page module to render for this slot. Optional — when omitted, the
@@ -118,6 +122,7 @@ type BuildAppPageRouteElementOptions<TModule extends AppPageModule = AppPageModu
   rootNotFoundModule?: TModule | null;
   rootUnauthorizedModule?: TModule | null;
   route: AppPageRouteWiringRoute<TModule, TErrorModule>;
+  createPageElement?: (component: AppPageComponent, props: Readonly<Record<string, unknown>>) => ReactNode;
   searchParams?: unknown;
   slotOverrides?: Readonly<Record<string, AppPageSlotOverride<TModule>>> | null;
 };

package/dist/server/app-page-route-wiring.js

@@ -8,7 +8,7 @@ import { AppRouterScrollTarget } from "../shims/app-router-scroll.js";
 import { LayoutSegmentProvider } from "../shims/layout-segment-context.js";
 import { MetadataHead, ViewportHead, renderMetadataToHtml } from "../shims/metadata.js";
 import { Children as Children$1, ParallelSlot, Slot } from "../shims/slot.js";
-import { resolveAppPageSegmentParamScopeKeys, resolveAppPageSegmentParams } from "./app-page-params.js";
+import { resolveAppPageBranchParams, resolveAppPageSegmentParamScopeKeys, resolveAppPageSegmentParams } from "./app-page-params.js";
 import { probeReactServerSubtree } from "./app-page-probe.js";
 import { resolveAppPageChildSegments, resolveAppPageRouteStateKey, resolveAppPageSegmentStateKey } from "./app-page-segment-state.js";
 import { Fragment, Suspense } from "react";
@@ -16,6 +16,9 @@ import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 //#region src/server/app-page-route-wiring.tsx
 const APP_PAGE_LAYOUT_PROBE_CHILD = /* @__PURE__ */ jsx(Fragment, {});
 const DEFAULT_GLOBAL_ERROR_COMPONENT = DefaultGlobalError;
+function resolveSlotLayoutParams(routeSegments, treePosition, params) {
+	return resolveAppPageBranchParams(routeSegments, treePosition, params);
+}
 function getDefaultExport(module) {
 	return module?.default ?? null;
 }
@@ -249,13 +252,7 @@ function buildAppPageElements(options) {
 		if (!templateComponent) continue;
 		const TemplateComponent = templateComponent;
 		const templateDependency = templateDependenciesById.get(templateEntry.id);
-		const templateElement = templateDependency ? renderWithAppDependencyBarrier(/* @__PURE__ */ jsx(TemplateComponent, {
-			params: options.matchedParams,
-			children: /* @__PURE__ */ jsx(Children$1, {})
-		}), templateDependency) : /* @__PURE__ */ jsx(TemplateComponent, {
-			params: options.matchedParams,
-			children: /* @__PURE__ */ jsx(Children$1, {})
-		});
+		const templateElement = templateDependency ? renderWithAppDependencyBarrier(/* @__PURE__ */ jsx(TemplateComponent, { children: /* @__PURE__ */ jsx(Children$1, {}) }), templateDependency) : /* @__PURE__ */ jsx(TemplateComponent, { children: /* @__PURE__ */ jsx(Children$1, {}) });
 		elements[templateEntry.id] = renderAfterAppDependencies(templateElement, templateDependenciesBeforeById.get(templateEntry.id) ?? []);
 	}
 	for (let index = 0; index < layoutEntries.length; index++) {
@@ -293,7 +290,9 @@ function buildAppPageElements(options) {
 		const slotId = resolveAppPageSlotId(slot, layoutEntries[targetIndex]?.treePath ?? "/");
 		const slotOverride = resolveSlotOverride(slotKey, slotName);
 		const slotParams = getEffectiveSlotParams(slotKey, slotName);
-		const slotResetKey = resolveAppPageRouteStateKey(slot.routeSegments ?? [], slotParams);
+		const slotRouteSegments = slot.routeSegments ?? [];
+		const slotOwnerParams = resolveAppPageSegmentParams(options.route.routeSegments, layoutEntries[targetIndex]?.treePosition ?? 0, options.matchedParams);
+		const slotResetKey = resolveAppPageRouteStateKey(slotRouteSegments, slotParams);
 		const overrideOrPageComponent = getDefaultExport(slotOverride?.pageModule) ?? getDefaultExport(slot.page);
 		const defaultComponent = getDefaultExport(slot.default);
 		if (!overrideOrPageComponent && defaultComponent && options.isRscRequest && options.mountedSlotIds?.has(slotId)) continue;
@@ -302,23 +301,40 @@ function buildAppPageElements(options) {
 			elements[slotId] = AppElementsWire.unmatchedSlotValue;
 			continue;
 		}
-		const slotThenableParams = options.makeThenableParams(slotParams);
-		const slotProps = { params: slotThenableParams };
+		const slotProps = { params: options.makeThenableParams(slotParams) };
 		if (options.searchParams !== void 0) slotProps.searchParams = options.searchParams;
 		if (slotOverride?.props) Object.assign(slotProps, slotOverride.props);
-		let slotElement = /* @__PURE__ */ jsx(slotComponent, { ...slotProps });
+		let slotElement = options.createPageElement ? options.createPageElement(slotComponent, slotProps) : (() => {
+			return /* @__PURE__ */ jsx(slotComponent, { ...slotProps });
+		})();
+		const hasSlotTreeOverride = slotOverride?.pageModule != null || slotOverride?.layoutModules !== void 0;
 		const interceptLayouts = slotOverride?.layoutModules ?? [];
 		for (let layoutIndex = interceptLayouts.length - 1; layoutIndex >= 0; layoutIndex--) {
 			const interceptLayoutComponent = getDefaultExport(interceptLayouts[layoutIndex]);
 			if (!interceptLayoutComponent) continue;
-			slotElement = /* @__PURE__ */ jsx(interceptLayoutComponent, {
-				params: slotThenableParams,
+			const InterceptLayoutComponent = interceptLayoutComponent;
+			const interceptLayoutParams = resolveSlotLayoutParams(slotOverride?.branchSegments ?? slotRouteSegments, slotOverride?.layoutSegments?.[layoutIndex]?.length ?? slotRouteSegments.length, slotParams);
+			slotElement = /* @__PURE__ */ jsx(InterceptLayoutComponent, {
+				params: options.makeThenableParams(interceptLayoutParams),
+				children: slotElement
+			});
+		}
+		if (!hasSlotTreeOverride) for (let layoutIndex = (slot.configLayouts?.length ?? 0) - 1; layoutIndex >= 0; layoutIndex--) {
+			const nestedLayoutComponent = getDefaultExport(slot.configLayouts?.[layoutIndex]);
+			if (!nestedLayoutComponent) continue;
+			const NestedLayoutComponent = nestedLayoutComponent;
+			const nestedLayoutParams = resolveSlotLayoutParams(slotRouteSegments, slot.configLayoutTreePositions?.[layoutIndex] ?? 0, slotParams);
+			slotElement = /* @__PURE__ */ jsx(NestedLayoutComponent, {
+				params: options.makeThenableParams({
+					...slotOwnerParams,
+					...nestedLayoutParams
+				}),
 				children: slotElement
 			});
 		}
 		const slotLayoutComponent = getDefaultExport(slot.layout);
 		if (slotLayoutComponent) slotElement = /* @__PURE__ */ jsx(slotLayoutComponent, {
-			params: slotThenableParams,
+			params: options.makeThenableParams(slotOwnerParams),
 			children: slotElement
 		});
 		const slotLoadingComponent = getDefaultExport(slot.loading);

package/dist/server/app-page-search-params-observation.d.ts

@@ -1,10 +1,12 @@
+import { ThenableParams, ThenableParamsObserver } from "../shims/thenable-params.js";
 import { AppPageSearchParams } from "./app-page-head.js";
-import { ThenableParams } from "../shims/thenable-params.js";
 
 //#region src/server/app-page-search-params-observation.d.ts
 type AppPageSearchParamsObservationOptions = {
+  markDynamic?: boolean;
   observeReactPromiseStatus?: boolean;
 };
+declare function createAppPageSearchParamsObserver(options?: AppPageSearchParamsObservationOptions): ThenableParamsObserver;
 declare function makeObservedAppPageSearchParamsThenable(pageSearchParams: AppPageSearchParams, options?: AppPageSearchParamsObservationOptions): ThenableParams<AppPageSearchParams>;
 //#endregion
-export { makeObservedAppPageSearchParamsThenable };
+export { createAppPageSearchParamsObserver, makeObservedAppPageSearchParamsThenable };

package/dist/server/app-page-search-params-observation.js

@@ -1,15 +1,19 @@
-import { markDynamicUsage, markRenderRequestApiUsage, throwIfInsideCacheScope } from "../shims/headers.js";
+import { markDynamicUsage, markRenderRequestApiUsage, throwIfInsideCacheScope, throwIfStaticGenerationAccessError } from "../shims/headers.js";
 import { makeThenableParams } from "../shims/thenable-params.js";
 //#region src/server/app-page-search-params-observation.ts
-function markAppPageSearchParamsAccess() {
+function markAppPageSearchParamsAccess(markDynamic) {
+	throwIfStaticGenerationAccessError();
 	throwIfInsideCacheScope("searchParams");
-	markDynamicUsage();
+	if (markDynamic) markDynamicUsage();
 	markRenderRequestApiUsage("searchParams");
 }
-function makeObservedAppPageSearchParamsThenable(pageSearchParams, options = {}) {
-	const observer = { observeParamAccess() {
-		markAppPageSearchParamsAccess();
+function createAppPageSearchParamsObserver(options = {}) {
+	return { observeParamAccess() {
+		markAppPageSearchParamsAccess(options.markDynamic !== false);
 	} };
+}
+function makeObservedAppPageSearchParamsThenable(pageSearchParams, options = {}) {
+	const observer = createAppPageSearchParamsObserver(options);
 	if (options.observeReactPromiseStatus === true) return makeThenableParams(pageSearchParams, {
 		...observer,
 		observeReactPromiseStatus: true
@@ -17,4 +21,4 @@ function makeObservedAppPageSearchParamsThenable(pageSearchParams, options = {})
 	return makeThenableParams(pageSearchParams, observer);
 }
 //#endregion
-export { makeObservedAppPageSearchParamsThenable };
+export { createAppPageSearchParamsObserver, makeObservedAppPageSearchParamsThenable };

package/dist/server/app-page-segment-state.js

@@ -1,5 +1,6 @@
 import { isCatchAllSegment, isOptionalCatchAllSegment } from "../routing/utils.js";
 //#region src/server/app-page-segment-state.ts
+const APP_PAGE_SEGMENT_KEY = "__PAGE__";
 function isDynamicSegment(segment) {
 	return segment.startsWith("[") && segment.endsWith("]") && !segment.includes(".");
 }
@@ -58,6 +59,7 @@ function resolveAppPageChildSegments(routeSegments, treePosition, params) {
 		}
 		resolvedSegments.push(segment);
 	}
+	resolvedSegments.push(APP_PAGE_SEGMENT_KEY);
 	return resolvedSegments;
 }
 function resolveAppPageSegmentStateKey(routeSegments, treePosition, params) {

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

@@ -24,6 +24,7 @@ function buildRouteHandlerPageCacheTags(pathname, extraTags, routeSegments) {
 async function runInRouteHandlerRevalidationContext(options, renderFn) {
 	await runWithRequestContext(createRequestContext({
 		headersContext: createStaticGenerationHeadersContext({
+			draftModeEnabled: false,
 			draftModeSecret: options.draftModeSecret,
 			dynamicConfig: options.dynamicConfig,
 			routeKind: "route",

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

@@ -1,4 +1,5 @@
-import { setHeadersContext } from "../shims/headers.js";
+import { isDraftModeRequest, setHeadersContext } from "../shims/headers.js";
+import { runWithRootParamsUsage } from "../shims/root-params.js";
 import { isPossibleAppRouteActionRequest } from "./app-action-request.js";
 import { applyRouteHandlerMiddlewareContext, applyRouteHandlerRevalidateHeader, assertSupportedAppRouteHandlerResponse, buildAppRouteCacheValue, finalizeRouteHandlerResponse, markRouteHandlerCacheMiss } from "./app-route-handler-response.js";
 import { createTrackedAppRouteRequest, markKnownDynamicAppRoute } from "./app-route-handler-runtime.js";
@@ -8,6 +9,7 @@ import { resolveAppRouteHandlerSpecialError, shouldApplyAppRouteHandlerRevalidat
 function configureAppRouteStaticGenerationContext(options) {
 	if (options.dynamicConfig === "force-static" || options.dynamicConfig === "error") {
 		setHeadersContext(createStaticGenerationHeadersContext({
+			draftModeEnabled: options.draftModeSecret !== void 0 && isDraftModeRequest(options.request, options.draftModeSecret),
 			draftModeSecret: options.draftModeSecret,
 			dynamicConfig: options.dynamicConfig,
 			routeKind: "route",
@@ -32,7 +34,10 @@ async function runAppRouteHandler(options) {
 			return getAppRouteStaticGenerationErrorMessage(options.routePattern, expression);
 		}
 	});
-	const response = await options.handlerFn(trackedRequest.request, { params: options.params });
+	const response = await runWithRootParamsUsage({
+		kind: "route-handler",
+		routePattern: options.routePattern ?? new URL(options.request.url).pathname
+	}, () => options.handlerFn(trackedRequest.request, { params: options.params }));
 	return {
 		dynamicUsedInHandler: options.consumeDynamicUsage(),
 		response

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

@@ -1,3 +1,4 @@
+import "../utils/protocol-headers.js";
 import "./headers.js";
 import { processMiddlewareHeaders } from "./request-pipeline.js";
 import { setCacheStateHeaders } from "./cache-headers.js";

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

@@ -1,5 +1,5 @@
 import { addBasePathToPathname } from "../utils/base-path.js";
-import { buildRequestHeadersFromMiddlewareResponse } from "./middleware-request-headers.js";
+import { buildRequestHeadersFromMiddlewareResponse } from "../utils/middleware-request-headers.js";
 import { NextRequest, RequestCookies, sealRequestCookies, sealRequestHeaders } from "../shims/server.js";
 //#region src/server/app-route-handler-runtime.ts
 const ROUTE_HANDLER_HTTP_METHODS = [

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

@@ -36,11 +36,13 @@ type LazyLoadableSlot = {
   page?: unknown;
   default?: unknown;
   layout?: unknown;
+  configLayouts?: readonly unknown[];
   loading?: unknown;
   error?: unknown;
   __loadPage?: LazyModuleThunk | null;
   __loadDefault?: LazyModuleThunk | null;
   __loadLayout?: LazyModuleThunk | null;
+  __loadConfigLayouts?: LazyModuleLoaderArray | null;
   __loadLoading?: LazyModuleThunk | null;
   __loadError?: LazyModuleThunk | null; /** Hydrated only after an intercept matches, not with the slot's base modules. */
   intercepts?: LazyLoadableIntercept[];

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

@@ -61,6 +61,7 @@ function ensureAppRouteModulesLoaded(route) {
 		pushFieldLoad(loads, slot, "page", slot.__loadPage);
 		pushFieldLoad(loads, slot, "default", slot.__loadDefault);
 		pushFieldLoad(loads, slot, "layout", slot.__loadLayout);
+		pushArrayLoads(loads, slot.configLayouts, slot.__loadConfigLayouts);
 		pushFieldLoad(loads, slot, "loading", slot.__loadLoading);
 		pushFieldLoad(loads, slot, "error", slot.__loadError);
 	}

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

@@ -5,6 +5,18 @@ type WorkerAssetEnv = {
   ASSETS?: {
     fetch(request: Request): Promise<Response> | Response;
   };
+  IMAGES?: {
+    input(stream: ReadableStream): {
+      transform(options: Record<string, unknown>): {
+        output(options: {
+          format: string;
+          quality: number;
+        }): Promise<{
+          response(): Response;
+        }>;
+      };
+    };
+  };
 };
 declare const _default: {
   fetch(request: Request, env?: WorkerAssetEnv, ctx?: ExecutionContextLike): Promise<Response>;

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

@@ -1,14 +1,17 @@
 import "./server-globals.js";
 import { runWithExecutionContext } from "../shims/request-context.js";
-import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } from "./headers.js";
+import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } from "../utils/protocol-headers.js";
 import { badRequestResponse, notFoundResponse, notFoundStaticAssetResponse } from "./http-error-responses.js";
 import { isOpenRedirectShaped } from "./open-redirect.js";
 import { bufferRequestBodyForHeaderClone, cloneRequestWithHeaders, filterInternalHeaders } from "./request-pipeline.js";
+import { getImageOptimizer, handleConfiguredImageOptimization, isImageOptimizationPath } from "./image-optimization.js";
 import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
-import { resolveStaticAssetSignal } from "./worker-utils.js";
+import { finalizeMissingStaticAssetResponse, resolveStaticAssetSignal } from "./worker-utils.js";
 import { readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
-import rscHandler, { __assetPrefix, __basePath } from "virtual:vinext-rsc-entry";
+import { handleAppRouterImageOptimizationRequest } from "./app-router-image-optimization.js";
+import rscHandler, { __assetPrefix, __basePath, __imageAllowedWidths, __imageConfig } from "virtual:vinext-rsc-entry";
 import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
+import { registerConfiguredImageOptimizer } from "virtual:vinext-image-adapters";
 //#region src/server/app-router-entry.ts
 const __workerBasePath = typeof __basePath === "string" ? __basePath : "";
 const __workerAssetPathPrefix = assetPrefixPathname(typeof __assetPrefix === "string" ? __assetPrefix : "");
@@ -17,14 +20,19 @@ var app_router_entry_default = { async fetch(request, env, ctx) {
 } };
 async function handleRequest(request, env, ctx) {
 	registerConfiguredCacheAdapters(env);
+	registerConfiguredImageOptimizer(env);
 	const url = new URL(request.url);
+	if (isImageOptimizationPath(url.pathname) && env?.ASSETS && getImageOptimizer()) {
+		const assetFetcher = env.ASSETS;
+		return handleConfiguredImageOptimization(request, (assetPath) => Promise.resolve(assetFetcher.fetch(new Request(new URL(assetPath, request.url)))), __imageAllowedWidths, __imageConfig);
+	}
 	if (isOpenRedirectShaped(url.pathname)) return notFoundResponse();
 	try {
 		decodeURIComponent(url.pathname);
 	} catch {
 		return badRequestResponse();
 	}
-	if (isNextStaticPath(url.pathname, __workerBasePath, __workerAssetPathPrefix)) return notFoundStaticAssetResponse();
+	const missingBuildAsset = isNextStaticPath(url.pathname, __workerBasePath, __workerAssetPathPrefix);
 	{
 		request = await bufferRequestBodyForHeaderClone(request);
 		const prerenderRouteParamsPayload = readTrustedPrerenderRouteParams(request);
@@ -33,17 +41,23 @@ async function handleRequest(request, env, ctx) {
 		if (prerenderRouteParamsHeader !== null) filteredHeaders.set(VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, prerenderRouteParamsHeader);
 		request = cloneRequestWithHeaders(request, filteredHeaders);
 	}
+	const imageResponse = await handleAppRouterImageOptimizationRequest(request, {
+		basePath: __workerBasePath,
+		env: env ?? {}
+	});
+	if (imageResponse) return imageResponse;
 	const handleFn = () => rscHandler(request, ctx);
 	const result = await (ctx ? runWithExecutionContext(ctx, handleFn) : handleFn());
 	if (result instanceof Response) {
+		let response = result;
 		if (env?.ASSETS) {
 			const assetFetcher = env.ASSETS;
-			const assetResponse = await resolveStaticAssetSignal(result, { fetchAsset: (path) => Promise.resolve(assetFetcher.fetch(new Request(new URL(path, request.url)))) });
-			if (assetResponse) return assetResponse;
+			const assetResponse = await resolveStaticAssetSignal(response, { fetchAsset: (path) => Promise.resolve(assetFetcher.fetch(new Request(new URL(path, request.url)))) });
+			if (assetResponse) response = assetResponse;
 		}
-		return result;
+		return finalizeMissingStaticAssetResponse(response, missingBuildAsset);
 	}
-	if (result === null || result === void 0) return notFoundResponse();
+	if (result === null || result === void 0) return missingBuildAsset ? notFoundStaticAssetResponse() : notFoundResponse();
 	return new Response(String(result), { status: 200 });
 }
 //#endregion