vinext 1.0.0-beta.2 → 1.0.0-beta.3

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

@@ -108,6 +108,60 @@ function createAppPageErrorEntries(route) {
 		}];
 	});
 }
+function createAppPageLoadingEntries(route) {
+	return (route.loadings ?? []).flatMap((loadingModule, index) => {
+		if (!loadingModule) return [];
+		const treePosition = route.loadingTreePositions?.[index];
+		if (treePosition === void 0) return [];
+		return [{
+			loadingModule,
+			treePosition
+		}];
+	});
+}
+function getPrefetchLoadingEntry(route) {
+	let firstEntry = null;
+	for (const [index, loadingModule] of (route.loadings ?? []).entries()) {
+		if (!getDefaultExport(loadingModule)) continue;
+		const treePosition = route.loadingTreePositions?.[index];
+		if (treePosition === void 0) continue;
+		if (firstEntry === null || treePosition < firstEntry.treePosition) firstEntry = {
+			loadingModule,
+			treePosition
+		};
+	}
+	if (firstEntry) return firstEntry;
+	return getDefaultExport(route.loading) ? {
+		loadingModule: route.loading,
+		treePosition: route.routeSegments?.length ?? 0
+	} : null;
+}
+function createAppPageSlotLoadingEntries(slot, override) {
+	const entries = [];
+	const slotLoadingModules = (slot.loadings?.length ?? 0) > 0 ? slot.loadings : slot.loading ? [slot.loading] : [];
+	const slotLoadingTreePositions = (slot.loadingTreePositions?.length ?? 0) > 0 ? slot.loadingTreePositions : [0];
+	for (const [index, loadingModule] of slotLoadingModules.entries()) {
+		const treePosition = slotLoadingTreePositions[index];
+		if (!getDefaultExport(loadingModule) || treePosition === void 0) continue;
+		if (override && treePosition !== 0) continue;
+		entries.push({
+			loadingModule,
+			treePosition
+		});
+	}
+	for (const [index, loadingModule] of (override?.loadingModules ?? []).entries()) {
+		const treePosition = override?.loadingTreePositions?.[index];
+		if (!getDefaultExport(loadingModule) || treePosition === void 0) continue;
+		entries.push({
+			loadingModule,
+			treePosition
+		});
+	}
+	return entries;
+}
+function getFirstLoadingEntry(entries) {
+	return entries.reduce((first, entry) => first === null || entry.treePosition < first.treePosition ? entry : first, null);
+}
 function createAppPageParallelSlotEntries(layoutIndex, layoutEntries, route, getEffectiveSlotParams, resolveSlotOverride) {
 	const parallelSlots = {};
 	for (const [slotKey, slot] of Object.entries(route.slots ?? {})) {
@@ -223,13 +277,26 @@ function buildAppPageElements(options) {
 	const streamingMetadataOutletId = options.streamingMetadataOutlet ? `__vinext_streaming_metadata_outlet:${routeId}` : null;
 	const layoutEntries = createAppPageLayoutEntries(options.route);
 	const templateEntries = createAppPageTemplateEntries(options.route);
+	const loadingEntries = createAppPageLoadingEntries(options.route);
 	const errorEntries = createAppPageErrorEntries(options.route);
+	const findNearestAncestorLoadingEntry = (treePosition) => {
+		for (let index = loadingEntries.length - 1; index >= 0; index--) if (loadingEntries[index].treePosition < treePosition) return loadingEntries[index];
+	};
+	const findNearestLoadingEntryAtOrAbove = (treePosition) => {
+		let nearest;
+		for (const entry of loadingEntries) if (entry.treePosition <= treePosition && (!nearest || entry.treePosition > nearest.treePosition)) nearest = entry;
+		return nearest;
+	};
+	const isPrefetchLoadingShell = renderMode === APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL;
+	const prefetchLoadingEntry = isPrefetchLoadingShell ? getPrefetchLoadingEntry(options.route) : null;
 	const metadataPlacement = options.metadataPlacement ?? "head";
 	const layoutEntriesByTreePosition = /* @__PURE__ */ new Map();
 	const templateEntriesByTreePosition = /* @__PURE__ */ new Map();
+	const loadingEntriesByTreePosition = /* @__PURE__ */ new Map();
 	const errorEntriesByTreePosition = /* @__PURE__ */ new Map();
 	for (const layoutEntry of layoutEntries) layoutEntriesByTreePosition.set(layoutEntry.treePosition, layoutEntry);
 	for (const templateEntry of templateEntries) templateEntriesByTreePosition.set(templateEntry.treePosition, templateEntry);
+	for (const loadingEntry of loadingEntries) loadingEntriesByTreePosition.set(loadingEntry.treePosition, loadingEntry);
 	for (const errorEntry of errorEntries) errorEntriesByTreePosition.set(errorEntry.treePosition, errorEntry);
 	const layoutIndicesByTreePosition = /* @__PURE__ */ new Map();
 	for (let index = 0; index < layoutEntries.length; index++) layoutIndicesByTreePosition.set(layoutEntries[index].treePosition, index);
@@ -249,6 +316,7 @@ function buildAppPageElements(options) {
 	const orderedTreePositions = Array.from(/* @__PURE__ */ new Set([
 		...layoutEntries.map((entry) => entry.treePosition),
 		...templateEntries.map((entry) => entry.treePosition),
+		...loadingEntries.map((entry) => entry.treePosition),
 		...errorEntries.map((entry) => entry.treePosition)
 	])).sort((left, right) => left - right);
 	const resolveSlotOverride = (slotKey, slotName) => {
@@ -256,6 +324,11 @@ function buildAppPageElements(options) {
 		if (overrideByKey) return overrideByKey;
 		if (slotKey === slotName || (slotNameCounts.get(slotName) ?? 0) === 1) return options.slotOverrides?.[slotName];
 	};
+	const prefetchSlotLoadingEntries = isPrefetchLoadingShell ? Object.entries(options.route.slots ?? {}).flatMap(([slotKey, slot]) => {
+		return getFirstLoadingEntry(createAppPageSlotLoadingEntries(slot, resolveSlotOverride(slotKey, slot.name) ?? null)) ? [{ ownerTreePosition: slot.ownerTreePosition ?? 0 }] : [];
+	}) : [];
+	const prefetchCutoffTreePosition = isPrefetchLoadingShell ? prefetchLoadingEntry?.treePosition ?? prefetchSlotLoadingEntries.reduce((deepest, entry) => Math.max(deepest, entry.ownerTreePosition), 0) : null;
+	const includesPrefetchTreePosition = (treePosition) => prefetchCutoffTreePosition === null || treePosition <= prefetchCutoffTreePosition;
 	const elements = { ...AppElementsWire.createMetadataEntries({
 		interception: renderIdentity?.interception ?? options.interception ?? null,
 		interceptionContext,
@@ -278,6 +351,7 @@ function buildAppPageElements(options) {
 	if (options.streamingMetadataOutlet && streamingMetadataOutletId) elements[streamingMetadataOutletId] = /* @__PURE__ */ jsx(AppPageMetadataOutlet, { metadata: options.streamingMetadataOutlet });
 	const getEffectiveSlotParams = (slotKey, slotName) => resolveSlotOverride(slotKey, slotName)?.params ?? options.matchedParams;
 	for (const treePosition of orderedTreePositions) {
+		if (isPrefetchLoadingShell && !includesPrefetchTreePosition(treePosition)) continue;
 		const layoutIndex = layoutIndicesByTreePosition.get(treePosition);
 		if (layoutIndex !== void 0) {
 			const layoutEntry = layoutEntries[layoutIndex];
@@ -298,19 +372,31 @@ function buildAppPageElements(options) {
 		pageDependencies.push(templateDependency);
 	}
 	const routeLoadingComponent = getDefaultExport(options.route.loading);
-	const isPrefetchLoadingShell = renderMode === APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL;
-	if (isPrefetchLoadingShell && routeLoadingComponent !== null) elements[APP_PREFETCH_LOADING_SHELL_MARKER_KEY] = "LoadingBoundary";
+	const prefetchLoadingComponent = getDefaultExport(prefetchLoadingEntry?.loadingModule);
+	if (isPrefetchLoadingShell && (prefetchLoadingComponent !== null || prefetchSlotLoadingEntries.length > 0)) elements[APP_PREFETCH_LOADING_SHELL_MARKER_KEY] = "LoadingBoundary";
 	elements[pageElementId] = isPrefetchLoadingShell ? null : renderAfterAppDependencies(options.element, pageDependencies);
 	for (const templateEntry of templateEntries) {
+		if (isPrefetchLoadingShell && !includesPrefetchTreePosition(templateEntry.treePosition)) continue;
 		const templateComponent = getDefaultExport(templateEntry.templateModule);
 		if (!templateComponent) continue;
 		const TemplateComponent = templateComponent;
 		const templateDependency = templateDependenciesById.get(templateEntry.id);
-		const templateElement = templateDependency ? renderWithAppDependencyBarrier(/* @__PURE__ */ jsx(TemplateComponent, { children: /* @__PURE__ */ jsx(Children$1, {}) }), templateDependency) : /* @__PURE__ */ jsx(TemplateComponent, { children: /* @__PURE__ */ jsx(Children$1, {}) });
+		let templateElement = templateDependency ? renderWithAppDependencyBarrier(/* @__PURE__ */ jsx(TemplateComponent, { children: /* @__PURE__ */ jsx(Children$1, {}) }), templateDependency) : /* @__PURE__ */ jsx(TemplateComponent, { children: /* @__PURE__ */ jsx(Children$1, {}) });
+		const ancestorLoadingEntry = findNearestAncestorLoadingEntry(templateEntry.treePosition);
+		const ancestorLoadingComponent = getDefaultExport(ancestorLoadingEntry?.loadingModule);
+		if (ancestorLoadingComponent && ancestorLoadingEntry) {
+			const AncestorLoadingComponent = ancestorLoadingComponent;
+			const loadingResetKey = resolveAppPageSegmentStateKey(routeSegments, ancestorLoadingEntry.treePosition, options.matchedParams);
+			templateElement = /* @__PURE__ */ jsx(Suspense, {
+				fallback: /* @__PURE__ */ jsx(AncestorLoadingComponent, {}),
+				children: templateElement
+			}, loadingResetKey || routeResetKey);
+		}
 		elements[templateEntry.id] = renderAfterAppDependencies(templateElement, templateDependenciesBeforeById.get(templateEntry.id) ?? []);
 	}
 	for (let index = 0; index < layoutEntries.length; index++) {
 		const layoutEntry = layoutEntries[index];
+		if (isPrefetchLoadingShell && !includesPrefetchTreePosition(layoutEntry.treePosition)) continue;
 		const layoutComponent = getDefaultExport(layoutEntry.layoutModule);
 		if (!layoutComponent) continue;
 		const layoutParams = resolveAppPageSegmentParams(options.route.routeSegments, layoutEntry.treePosition, options.matchedParams);
@@ -329,79 +415,146 @@ function buildAppPageElements(options) {
 		}
 		const LayoutComponent = layoutComponent;
 		const layoutDependency = layoutDependenciesByIndex.get(index);
-		const layoutElement = layoutDependency ? renderWithAppDependencyBarrier(/* @__PURE__ */ jsx(LayoutComponent, {
+		let layoutElement = layoutDependency ? renderWithAppDependencyBarrier(/* @__PURE__ */ jsx(LayoutComponent, {
 			...layoutProps,
 			children: /* @__PURE__ */ jsx(Children$1, {})
 		}), layoutDependency) : /* @__PURE__ */ jsx(LayoutComponent, {
 			...layoutProps,
 			children: /* @__PURE__ */ jsx(Children$1, {})
 		});
+		const ancestorLoadingEntry = findNearestAncestorLoadingEntry(layoutEntry.treePosition);
+		const ancestorLoadingComponent = getDefaultExport(ancestorLoadingEntry?.loadingModule);
+		if (ancestorLoadingComponent && ancestorLoadingEntry) {
+			const AncestorLoadingComponent = ancestorLoadingComponent;
+			const loadingResetKey = resolveAppPageSegmentStateKey(routeSegments, ancestorLoadingEntry.treePosition, options.matchedParams);
+			layoutElement = /* @__PURE__ */ jsx(Suspense, {
+				fallback: /* @__PURE__ */ jsx(AncestorLoadingComponent, {}),
+				children: layoutElement
+			}, loadingResetKey || routeResetKey);
+		}
 		elements[layoutEntry.id] = renderAfterAppDependencies(layoutElement, layoutDependenciesBefore[index] ?? []);
 	}
 	for (const [slotKey, slot] of Object.entries(options.route.slots ?? {})) {
 		const slotName = slot.name;
 		const targetIndex = slot.layoutIndex >= 0 ? slot.layoutIndex : layoutEntries.length - 1;
+		const targetTreePosition = layoutEntries[targetIndex]?.treePosition ?? 0;
+		const ownerTreePosition = slot.ownerTreePosition ?? targetTreePosition;
+		const isOwnedAtRoutePrefetchCutoff = isPrefetchLoadingShell && prefetchLoadingEntry !== null && ownerTreePosition === prefetchLoadingEntry.treePosition;
+		if (isPrefetchLoadingShell && (prefetchLoadingEntry ? ownerTreePosition > prefetchLoadingEntry.treePosition : !includesPrefetchTreePosition(targetTreePosition))) continue;
 		const slotId = resolveAppPageSlotId(slot, layoutEntries[targetIndex]?.treePath ?? "/");
 		const slotOverride = resolveSlotOverride(slotKey, slotName);
 		const slotParams = getEffectiveSlotParams(slotKey, slotName);
 		const slotRouteSegments = slotOverride?.routeSegments ?? slot.routeSegments ?? [];
 		const slotOwnerParams = resolveAppPageSegmentParams(options.route.routeSegments, layoutEntries[targetIndex]?.treePosition ?? 0, options.matchedParams);
 		const slotResetKey = resolveAppPageRouteStateKey(slotRouteSegments, slotParams);
+		const hasSlotTreeOverride = slotOverride?.pageModule != null || slotOverride?.layoutModules !== void 0;
+		const slotLoadingEntries = createAppPageSlotLoadingEntries(slot, hasSlotTreeOverride ? slotOverride ?? null : null);
+		const prefetchSlotLoadingEntry = isOwnedAtRoutePrefetchCutoff ? prefetchLoadingEntry : isPrefetchLoadingShell ? getFirstLoadingEntry(slotLoadingEntries) : null;
+		if (isPrefetchLoadingShell && prefetchSlotLoadingEntry === null) continue;
 		const overrideOrPageComponent = getDefaultExport(slotOverride?.pageModule) ?? getDefaultExport(slot.page);
 		const defaultComponent = getDefaultExport(slot.default);
 		if (!overrideOrPageComponent && defaultComponent && options.isRscRequest && options.mountedSlotIds?.has(slotId)) continue;
 		const slotComponent = overrideOrPageComponent ?? defaultComponent;
-		if (!slotComponent) {
+		if (!slotComponent && !isOwnedAtRoutePrefetchCutoff) {
 			elements[slotId] = AppElementsWire.unmatchedSlotValue;
 			continue;
 		}
-		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 = 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;
-			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
+		let slotElement;
+		if (prefetchSlotLoadingEntry) slotElement = /* @__PURE__ */ jsx(getDefaultExport(prefetchSlotLoadingEntry.loadingModule), {});
+		else {
+			const slotProps = { params: options.makeThenableParams(slotParams) };
+			if (options.searchParams !== void 0) slotProps.searchParams = options.searchParams;
+			if (slotOverride?.props) Object.assign(slotProps, slotOverride.props);
+			slotElement = options.createPageElement ? options.createPageElement(slotComponent, slotProps) : (() => {
+				return /* @__PURE__ */ jsx(slotComponent, { ...slotProps });
+			})();
+		}
+		const branchSegments = slotOverride?.branchSegments ?? slotRouteSegments;
+		const branchLayouts = /* @__PURE__ */ new Map();
+		const addBranchLayout = (treePosition, entry) => {
+			const entries = branchLayouts.get(treePosition) ?? [];
+			entries.push(entry);
+			branchLayouts.set(treePosition, entries);
+		};
+		if (hasSlotTreeOverride) for (const [layoutIndex, layoutModule] of (slotOverride?.layoutModules ?? []).entries()) {
+			const component = getDefaultExport(layoutModule);
+			if (!component) continue;
+			const treePosition = slotOverride?.layoutSegments?.[layoutIndex]?.length ?? branchSegments.length;
+			addBranchLayout(treePosition, {
+				component,
+				params: resolveSlotLayoutParams(branchSegments, treePosition, slotParams)
 			});
 		}
-		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({
+		else for (const [layoutIndex, layoutModule] of (slot.configLayouts ?? []).entries()) {
+			const component = getDefaultExport(layoutModule);
+			if (!component) continue;
+			const treePosition = slot.configLayoutTreePositions?.[layoutIndex] ?? 0;
+			addBranchLayout(treePosition, {
+				component,
+				params: {
 					...slotOwnerParams,
-					...nestedLayoutParams
-				}),
-				children: slotElement
+					...resolveSlotLayoutParams(slotRouteSegments, treePosition, slotParams)
+				}
 			});
 		}
 		const slotLayoutComponent = overrideOrPageComponent ? getDefaultExport(slot.layout) : null;
-		if (slotLayoutComponent) slotElement = /* @__PURE__ */ jsx(slotLayoutComponent, {
-			params: options.makeThenableParams(slotOwnerParams),
-			children: slotElement
-		});
-		const slotLoadingComponent = getDefaultExport(slot.loading);
-		if (slotLoadingComponent) slotElement = /* @__PURE__ */ jsx(Suspense, {
-			fallback: /* @__PURE__ */ jsx(slotLoadingComponent, {}),
-			children: slotElement
-		}, slotResetKey);
+		if (slotLayoutComponent) {
+			const rootEntries = branchLayouts.get(0) ?? [];
+			branchLayouts.set(0, [{
+				component: slotLayoutComponent,
+				params: slotOwnerParams
+			}, ...rootEntries]);
+		}
+		const branchLoadings = /* @__PURE__ */ new Map();
+		for (const entry of slotLoadingEntries) {
+			const component = getDefaultExport(entry.loadingModule);
+			if (!component) continue;
+			const components = branchLoadings.get(entry.treePosition) ?? [];
+			components.push(component);
+			branchLoadings.set(entry.treePosition, components);
+		}
 		const slotErrorComponent = getErrorBoundaryExport(slot.error);
-		if (slotErrorComponent) slotElement = /* @__PURE__ */ jsx(ErrorBoundary, {
-			resetKey: slotResetKey,
-			fallback: slotErrorComponent,
-			children: slotElement
-		});
+		const branchTreePositions = Array.from(/* @__PURE__ */ new Set([
+			...branchLayouts.keys(),
+			...branchLoadings.keys(),
+			...slotErrorComponent ? [0] : []
+		])).filter((treePosition) => !prefetchSlotLoadingEntry || !isOwnedAtRoutePrefetchCutoff && treePosition <= prefetchSlotLoadingEntry.treePosition).sort((left, right) => left - right);
+		for (let index = branchTreePositions.length - 1; index >= 0; index--) {
+			const treePosition = branchTreePositions[index];
+			const loadingComponents = prefetchSlotLoadingEntry ? [] : branchLoadings.get(treePosition) ?? [];
+			for (let loadingIndex = loadingComponents.length - 1; loadingIndex >= 0; loadingIndex--) {
+				const LoadingComponent = loadingComponents[loadingIndex];
+				const loadingResetKey = resolveAppPageSegmentStateKey(branchSegments, treePosition, slotParams);
+				slotElement = /* @__PURE__ */ jsx(Suspense, {
+					fallback: /* @__PURE__ */ jsx(LoadingComponent, {}),
+					children: slotElement
+				}, loadingResetKey || slotResetKey);
+			}
+			if (treePosition === 0 && slotErrorComponent) slotElement = /* @__PURE__ */ jsx(ErrorBoundary, {
+				resetKey: slotResetKey,
+				fallback: slotErrorComponent,
+				children: slotElement
+			});
+			const layoutEntriesAtPosition = branchLayouts.get(treePosition) ?? [];
+			for (let layoutIndex = layoutEntriesAtPosition.length - 1; layoutIndex >= 0; layoutIndex--) {
+				const layoutEntry = layoutEntriesAtPosition[layoutIndex];
+				const LayoutComponent = layoutEntry.component;
+				slotElement = /* @__PURE__ */ jsx(LayoutComponent, {
+					params: options.makeThenableParams(layoutEntry.params),
+					children: slotElement
+				});
+			}
+		}
+		const ownerLoadingEntry = isPrefetchLoadingShell ? void 0 : findNearestLoadingEntryAtOrAbove(ownerTreePosition);
+		const ownerLoadingComponent = getDefaultExport(ownerLoadingEntry?.loadingModule);
+		if (ownerLoadingComponent && ownerLoadingEntry) {
+			const OwnerLoadingComponent = ownerLoadingComponent;
+			const ownerResetKey = resolveAppPageSegmentStateKey(routeSegments, ownerLoadingEntry.treePosition, options.matchedParams);
+			slotElement = /* @__PURE__ */ jsx(Suspense, {
+				fallback: /* @__PURE__ */ jsx(OwnerLoadingComponent, {}),
+				children: slotElement
+			}, ownerResetKey || slotResetKey);
+		}
 		elements[slotId] = renderAfterAppDependencies(slotElement, targetIndex >= 0 ? slotDependenciesByLayoutIndex[targetIndex] ?? [] : []);
 	}
 	let routeChildren = /* @__PURE__ */ jsxs(Fragment$1, { children: [/* @__PURE__ */ jsx(LayoutSegmentProvider, {
@@ -409,8 +562,8 @@ function buildAppPageElements(options) {
 		segmentMap: { children: [APP_PAGE_SEGMENT_KEY] },
 		children: /* @__PURE__ */ jsx(Slot, { id: pageElementId })
 	}), createAppPageStreamingMetadataOutlet(streamingMetadataOutletId, options.streamingMetadataOutletSuspended)] });
-	if (isPrefetchLoadingShell) if (routeLoadingComponent === null) routeChildren = null;
-	else routeChildren = /* @__PURE__ */ jsx(routeLoadingComponent, {});
+	if (isPrefetchLoadingShell) if (prefetchLoadingComponent === null) routeChildren = null;
+	else routeChildren = /* @__PURE__ */ jsx(prefetchLoadingComponent, {});
 	else {
 		routeChildren = /* @__PURE__ */ jsx(RedirectBoundary, { children: routeChildren });
 		if (routeLoadingComponent) routeChildren = /* @__PURE__ */ jsx(Suspense, {
@@ -444,13 +597,22 @@ function buildAppPageElements(options) {
 		fallback: pageErrorComponent,
 		children: routeChildren
 	});
-	for (let index = orderedTreePositions.length - 1; index >= 0; index--) {
-		const treePosition = orderedTreePositions[index];
+	const renderedTreePositions = isPrefetchLoadingShell ? orderedTreePositions.filter(includesPrefetchTreePosition) : orderedTreePositions;
+	for (let index = renderedTreePositions.length - 1; index >= 0; index--) {
+		const treePosition = renderedTreePositions[index];
 		const segmentResetKey = resolveAppPageSegmentStateKey(routeSegments, treePosition, options.matchedParams);
 		let segmentChildren = routeChildren;
 		const layoutEntry = layoutEntriesByTreePosition.get(treePosition);
 		const templateEntry = templateEntriesByTreePosition.get(treePosition);
+		const loadingEntry = loadingEntriesByTreePosition.get(treePosition);
 		const errorEntry = errorEntriesByTreePosition.get(treePosition);
+		if (!isPrefetchLoadingShell && treePosition < routeSegments.length) {
+			const segmentLoadingComponent = getDefaultExport(loadingEntry?.loadingModule);
+			if (segmentLoadingComponent) segmentChildren = /* @__PURE__ */ jsx(Suspense, {
+				fallback: /* @__PURE__ */ jsx(segmentLoadingComponent, {}),
+				children: segmentChildren
+			}, segmentResetKey || routeResetKey);
+		}
 		if (layoutEntry) {
 			const layoutNotFoundComponent = getDefaultExport(layoutEntry.notFoundModule);
 			if (layoutNotFoundComponent) segmentChildren = /* @__PURE__ */ jsx(NotFoundBoundary, {

package/dist/server/app-pages-bridge.d.ts

@@ -2,7 +2,7 @@ import { AppMiddlewareContext } from "./app-middleware.js";
 
 //#region src/server/app-pages-bridge.d.ts
 type PagesEntry = {
-  handleApiRoute?: (request: Request, url: string) => Promise<Response> | Response;
+  handleApiRoute?: (request: Request, url: string, ctx?: unknown, trustedRevalidateOrigin?: string) => Promise<Response> | Response;
   matchApiRoute?: (url: string, request: Request) => PagesRouteMatch | null;
   matchPageRoute?: (url: string, request: Request) => PagesRouteMatch | null;
   renderPage?: (request: Request, url: string, query: Record<string, unknown>, parsedUrl: unknown, middlewareRequestHeaders?: Headers | null, options?: {

package/dist/server/app-pages-bridge.js

@@ -1,3 +1,4 @@
+import { getRequestExecutionContext } from "../shims/request-context.js";
 import { cloneRequestWithHeaders, cloneRequestWithUrl } from "./request-pipeline.js";
 import { pagesRouteHasPriorityOverAppRoute } from "./hybrid-route-priority.js";
 //#region src/server/app-pages-bridge.ts
@@ -26,7 +27,7 @@ async function renderPagesFallback(options, dependencies) {
 		if (appRouteMatch !== null) {
 			if (apiMatch === null || !pagesRouteHasPriorityOverAppRoute(apiMatch.route, appRouteMatch.route)) return null;
 		}
-		const pagesApiResponse = await pagesEntry.handleApiRoute(pagesRequest, pagesUrl);
+		const pagesApiResponse = await pagesEntry.handleApiRoute(pagesRequest, pagesUrl, void 0, getRequestExecutionContext()?.trustedRevalidateOrigin ?? new URL(pagesRequest.url).origin);
 		const draftCookie = getDraftModeCookieHeader();
 		return applyDraftModeCookie(applyRouteHandlerMiddlewareContext(pagesApiResponse, middlewareContext), draftCookie);
 	}

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

@@ -12,6 +12,10 @@ async function readAppRouteHandlerCacheResponse(options) {
 	try {
 		const cached = await options.isrGet(routeKey);
 		const cachedValue = getCachedAppRouteValue(cached);
+		if (cached?.isExpired) {
+			options.isrDebug?.("MISS (expired route)", options.cleanPathname);
+			return null;
+		}
 		if (cachedValue && !cached?.isStale) {
 			options.isrDebug?.("HIT (route)", options.cleanPathname);
 			options.clearRequestContext();

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

@@ -1,4 +1,4 @@
-import { createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
+import { closeAfterResponse, createRequestContext, runWithRequestContext } from "../shims/unified-request-context.js";
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { reportRequestError } from "./instrumentation.js";
 import { consumeDynamicUsage, getActiveDraftModeState, getAndClearPendingCookies, getDraftModeCookieHeader, isDraftModeRequest, markDynamicUsage, setHeadersAccessPhase } from "../shims/headers.js";
@@ -23,7 +23,7 @@ function buildRouteHandlerPageCacheTags(pathname, extraTags, routeSegments) {
 	return buildPageCacheTags(pathname, extraTags, routeSegments, "route");
 }
 async function runInRouteHandlerRevalidationContext(options, renderFn) {
-	await runWithRequestContext(createRequestContext({
+	const requestContext = createRequestContext({
 		headersContext: createStaticGenerationHeadersContext({
 			draftModeEnabled: false,
 			draftModeSecret: options.draftModeSecret,
@@ -33,7 +33,8 @@ async function runInRouteHandlerRevalidationContext(options, renderFn) {
 		}),
 		executionContext: getRequestExecutionContext(),
 		unstableCacheRevalidation: "foreground"
-	}), async () => {
+	});
+	const revalidation = runWithRequestContext(requestContext, async () => {
 		ensureFetchPatch();
 		setCurrentFetchSoftTags(buildRouteHandlerPageCacheTags(options.cleanPathname, [], options.routeSegments));
 		setCurrentFetchCacheMode(options.fetchCacheMode);
@@ -44,6 +45,11 @@ async function runInRouteHandlerRevalidationContext(options, renderFn) {
 			await _drainPendingRevalidations();
 		}
 	});
+	try {
+		await revalidation;
+	} finally {
+		await closeAfterResponse(requestContext);
+	}
 }
 async function dispatchAppRouteHandler(options) {
 	const { route } = options;

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

@@ -1,9 +1,9 @@
 import "../utils/protocol-headers.js";
 import "./headers.js";
 import { processMiddlewareHeaders } from "./request-pipeline.js";
-import { setCacheStateHeaders } from "./cache-headers.js";
 import { applyCdnResponseHeaders } from "./cache-control.js";
 import { buildAppRouteMissIsrCacheControl, decideIsr } from "./isr-decision.js";
+import { setCacheStateHeaders } from "./cache-headers.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { getSetCookieName } from "./cookie-utils.js";
 //#region src/server/app-route-handler-response.ts

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

@@ -28,6 +28,8 @@ type LazyModuleLoaderArray = readonly (LazyModuleThunk | null | undefined)[];
 type LazyLoadableIntercept = {
   interceptLayouts?: readonly unknown[] | null;
   __loadInterceptLayouts?: LazyModuleLoaderArray | null;
+  interceptLoadings?: readonly unknown[] | null;
+  __loadInterceptLoadings?: LazyModuleLoaderArray | null;
   __loadState?: {
     interceptLayoutsLoading: Promise<readonly unknown[]> | null;
   };
@@ -38,6 +40,7 @@ type LazyLoadableSlot = {
   layout?: unknown;
   configLayouts?: readonly unknown[];
   loading?: unknown;
+  loadings?: readonly unknown[];
   error?: unknown;
   notFound?: unknown;
   __loadPage?: LazyModuleThunk | null;
@@ -45,6 +48,7 @@ type LazyLoadableSlot = {
   __loadLayout?: LazyModuleThunk | null;
   __loadConfigLayouts?: LazyModuleLoaderArray | null;
   __loadLoading?: LazyModuleThunk | null;
+  __loadLoadings?: LazyModuleLoaderArray | null;
   __loadError?: LazyModuleThunk | null;
   __loadNotFound?: LazyModuleThunk | null; /** Hydrated only after an intercept matches, not with the slot's base modules. */
   intercepts?: LazyLoadableIntercept[];
@@ -54,6 +58,7 @@ type LazyLoadableRoute = {
   routeHandler?: unknown;
   layouts?: unknown[];
   templates?: unknown[];
+  loadings?: unknown[];
   errors?: unknown[];
   errorPaths?: unknown[];
   notFounds?: unknown[];
@@ -70,6 +75,7 @@ type LazyLoadableRoute = {
   __loadRouteHandler?: LazyModuleThunk | null;
   __loadLayouts?: LazyModuleLoaderArray | null;
   __loadTemplates?: LazyModuleLoaderArray | null;
+  __loadLoadings?: LazyModuleLoaderArray | null;
   __loadErrors?: LazyModuleLoaderArray | null;
   __loadErrorPaths?: LazyModuleLoaderArray | null;
   __loadNotFounds?: LazyModuleLoaderArray | null;

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

@@ -20,6 +20,7 @@ function loadAppInterceptLayouts(intercept) {
 	if (loadState?.interceptLayoutsLoading) return loadState.interceptLayoutsLoading;
 	const loads = [];
 	pushArrayLoads(loads, intercept.interceptLayouts, intercept.__loadInterceptLayouts);
+	pushArrayLoads(loads, intercept.interceptLoadings, intercept.__loadInterceptLoadings);
 	if (loads.length === 0) return Promise.resolve(intercept.interceptLayouts ?? []);
 	const loading = Promise.all(loads).then(() => {
 		if (loadState) loadState.interceptLayoutsLoading = null;
@@ -52,6 +53,7 @@ function ensureAppRouteModulesLoaded(route) {
 	pushFieldLoad(loads, route, "unauthorized", route.__loadUnauthorized);
 	pushArrayLoads(loads, route.layouts, route.__loadLayouts);
 	pushArrayLoads(loads, route.templates, route.__loadTemplates);
+	pushArrayLoads(loads, route.loadings, route.__loadLoadings);
 	pushArrayLoads(loads, route.errors, route.__loadErrors);
 	pushArrayLoads(loads, route.errorPaths, route.__loadErrorPaths);
 	pushArrayLoads(loads, route.notFounds, route.__loadNotFounds);
@@ -63,6 +65,7 @@ function ensureAppRouteModulesLoaded(route) {
 		pushFieldLoad(loads, slot, "layout", slot.__loadLayout);
 		pushArrayLoads(loads, slot.configLayouts, slot.__loadConfigLayouts);
 		pushFieldLoad(loads, slot, "loading", slot.__loadLoading);
+		pushArrayLoads(loads, slot.loadings, slot.__loadLoadings);
 		pushFieldLoad(loads, slot, "error", slot.__loadError);
 		pushFieldLoad(loads, slot, "notFound", slot.__loadNotFound);
 	}

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

@@ -1,6 +1,6 @@
 import "./server-globals.js";
 import { runWithExecutionContext } from "../shims/request-context.js";
-import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER } from "../utils/protocol-headers.js";
+import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
 import { badRequestResponse, notFoundResponse, notFoundStaticAssetResponse } from "./http-error-responses.js";
 import { isOpenRedirectShaped } from "./open-redirect.js";
 import { cloneRequestWithHeaders, filterInternalHeaders } from "./request-pipeline.js";
@@ -8,6 +8,7 @@ import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js"
 import { getImageOptimizer, handleConfiguredImageOptimization, isImageOptimizationPath } from "./image-optimization.js";
 import { finalizeMissingStaticAssetResponse, resolveStaticAssetSignal } from "./worker-utils.js";
 import { readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
+import { createWorkerRevalidationContext } from "./worker-revalidation-context.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";
@@ -17,7 +18,8 @@ const __workerAssetPathPrefix = assetPrefixPathname(typeof __assetPrefix === "st
 var app_router_entry_default = { async fetch(request, env, ctx) {
 	return handleRequest(request, env, ctx);
 } };
-async function handleRequest(request, env, ctx) {
+async function handleRequest(request, env, platformCtx) {
+	const ctx = platformCtx?.trustedRevalidateOrigin ? platformCtx : createWorkerRevalidationContext(platformCtx, (internalRequest, internalCtx) => handleRequest(internalRequest, env, internalCtx));
 	registerConfiguredCacheAdapters(env);
 	registerConfiguredImageOptimizer(env);
 	const url = new URL(request.url);
@@ -34,7 +36,8 @@ async function handleRequest(request, env, ctx) {
 	const missingBuildAsset = isNextStaticPath(url.pathname, __workerBasePath, __workerAssetPathPrefix);
 	{
 		const prerenderRouteParamsPayload = readTrustedPrerenderRouteParams(request);
-		const filteredHeaders = filterInternalHeaders(request.headers);
+		const filteredHeaders = ctx.isInternalPagesRevalidation ? new Headers(request.headers) : filterInternalHeaders(request.headers);
+		filteredHeaders.delete(VINEXT_REVALIDATE_HOST_HEADER);
 		const prerenderRouteParamsHeader = serializePrerenderRouteParamsHeader(prerenderRouteParamsPayload);
 		if (prerenderRouteParamsHeader !== null) filteredHeaders.set(VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, prerenderRouteParamsHeader);
 		request = cloneRequestWithHeaders(request, filteredHeaders);

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

@@ -7,6 +7,11 @@ function hasDigest(error) {
 }
 const BAILOUT_TO_CSR_DIGEST = "BAILOUT_TO_CLIENT_SIDE_RENDERING";
 const DYNAMIC_SERVER_USAGE_DIGEST = "DYNAMIC_SERVER_USAGE";
+function isAbortError(error) {
+	if (!error || typeof error !== "object") return false;
+	const name = Reflect.get(error, "name");
+	return name === "AbortError" || name === "ResponseAborted";
+}
 /**
 * vinext's mirror of Next.js's `getDigestForWellKnownError`: returns the digest
 * string only when the error is a genuine control-flow signal — a redirect,
@@ -52,6 +57,7 @@ function sanitizeErrorForClient(error, nodeEnv = process.env.NODE_ENV) {
 function createRscOnErrorHandler(options) {
 	return (error) => {
 		const nodeEnv = options.nodeEnv ?? process.env.NODE_ENV;
+		if (isAbortError(error)) return;
 		const wellKnownDigest = getDigestForWellKnownError(error);
 		if (wellKnownDigest !== void 0) return wellKnownDigest;
 		if (nodeEnv !== "production" && error instanceof Error && error.message.includes("Only plain objects, and a few built-ins, can be passed to Client Components")) {
@@ -62,6 +68,10 @@ function createRscOnErrorHandler(options) {
 			const reportableError = typeof error === "object" && ORIGINAL_SERVER_ERROR in error ? Reflect.get(error, ORIGINAL_SERVER_ERROR) : error;
 			options.reportRequestError(reportableError instanceof Error ? reportableError : new Error(getThrownValueMessage(reportableError)), options.requestInfo, options.errorContext);
 		}
+		if (nodeEnv !== "production" && error && !hasDigest(error)) {
+			const loggableError = typeof error === "object" && ORIGINAL_SERVER_ERROR in error ? Reflect.get(error, ORIGINAL_SERVER_ERROR) : error;
+			console.error("[vinext] Server render error:", loggableError);
+		}
 		if (hasDigest(error)) return String(error.digest);
 		if (error) {
 			const digest = errorDigest(getThrownValueMessage(error) + getThrownValueStack(error));