vinext 0.0.55 → 0.1.1

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

@@ -1,3 +1,4 @@
+import { createAppRenderDependency, registerAppElementRenderDependencies, renderAfterAppDependencies, renderWithAppDependencyBarrier } from "./app-render-dependency.js";
 import { APP_STATIC_SIBLINGS_KEY, AppElementsWire, normalizeAppElementsSlotBindings } from "./app-elements-wire.js";
 import { APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, shouldSuppressLoadingBoundaries } from "./app-rsc-render-mode.js";
 import { APP_PREFETCH_LOADING_SHELL_MARKER_KEY } from "./app-elements.js";
@@ -6,12 +7,13 @@ 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 { createAppRenderDependency, renderAfterAppDependencies, renderWithAppDependencyBarrier } from "./app-render-dependency.js";
-import { resolveAppPageSegmentParams } from "./app-page-params.js";
+import { 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 { Suspense } from "react";
+import { Fragment, Suspense } from "react";
 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, {});
 function getDefaultExport(module) {
 	return module?.default ?? null;
 }
@@ -23,6 +25,38 @@ function createAppPageTreePath(routeSegments, treePosition) {
 	if (treePathSegments.length === 0) return "/";
 	return `/${treePathSegments.join("/")}`;
 }
+function readFiniteRevalidateSeconds(module) {
+	const revalidate = module?.revalidate;
+	return typeof revalidate === "number" && Number.isFinite(revalidate) && revalidate > 0 ? revalidate : null;
+}
+function recordLayoutSkipObservationScope(options) {
+	options.layoutParamAccess?.recordLayoutParamScope(options.layoutId, resolveAppPageSegmentParamScopeKeys(options.routeSegments, options.treePosition));
+	const revalidateSeconds = readFiniteRevalidateSeconds(options.layoutModule);
+	if (revalidateSeconds !== null) options.layoutParamAccess?.recordLayoutFiniteRevalidate(options.layoutId, revalidateSeconds);
+}
+function probeAppPageLayoutWithTracking(options) {
+	const treePosition = options.route.layoutTreePositions?.[options.layoutIndex] ?? 0;
+	const treePath = createAppPageTreePath(options.route.routeSegments, treePosition);
+	const layoutId = AppElementsWire.encodeLayoutId(treePath);
+	const probe = () => {
+		const layoutModule = options.route.layouts[options.layoutIndex];
+		const LayoutComponent = getDefaultExport(layoutModule);
+		if (!LayoutComponent) return null;
+		recordLayoutSkipObservationScope({
+			layoutId,
+			layoutModule,
+			layoutParamAccess: options.layoutParamAccess,
+			routeSegments: options.route.routeSegments,
+			treePosition
+		});
+		const layoutParams = resolveAppPageSegmentParams(options.route.routeSegments, treePosition, options.matchedParams);
+		return probeReactServerSubtree(/* @__PURE__ */ jsx(LayoutComponent, {
+			params: options.makeThenableParams(layoutParams, options.layoutParamAccess?.createThenableParamsObserver(layoutId)),
+			children: APP_PAGE_LAYOUT_PROBE_CHILD
+		}));
+	};
+	return options.layoutParamAccess ? options.layoutParamAccess.runLayoutProbe(layoutId, probe) : probe();
+}
 function createAppPageLayoutEntries(route) {
 	return route.layouts.map((layoutModule, index) => {
 		const treePosition = route.layoutTreePositions?.[index] ?? 0;
@@ -87,16 +121,20 @@ function resolveAppPageSlotBindingState(slot, override) {
 	if (getDefaultExport(slot.default)) return "default";
 	return "unmatched";
 }
-function createAppPageSlotBindings(route, layoutEntries, resolveSlotOverride) {
+function createAppPageSlotBindings(route, layoutEntries, resolveSlotOverride, options) {
 	const bindings = [];
 	for (const [slotKey, slot] of Object.entries(route.slots ?? {})) {
 		const layoutEntry = layoutEntries[slot.layoutIndex >= 0 ? slot.layoutIndex : layoutEntries.length - 1] ?? null;
 		const ownerLayoutId = layoutEntry?.id ?? null;
 		const override = resolveSlotOverride(slotKey, slot.name);
+		const slotId = resolveAppPageSlotId(slot, layoutEntry?.treePath ?? "/");
+		const state = resolveAppPageSlotBindingState(slot, override);
+		const activeRouteId = state === "active" ? options.interception?.slotId === slotId ? options.interception.targetRouteId : AppElementsWire.encodeRouteId(options.routePath, null) : null;
 		bindings.push({
+			...activeRouteId !== null ? { activeRouteId } : {},
 			ownerLayoutId,
-			slotId: resolveAppPageSlotId(slot, layoutEntry?.treePath ?? "/"),
-			state: resolveAppPageSlotBindingState(slot, override)
+			slotId,
+			state
 		});
 	}
 	return normalizeAppElementsSlotBindings(bindings, { layoutIds: layoutEntries.map((entry) => entry.id) });
@@ -139,6 +177,7 @@ function buildAppPageElements(options) {
 	const layoutIndicesByTreePosition = /* @__PURE__ */ new Map();
 	for (let index = 0; index < layoutEntries.length; index++) layoutIndicesByTreePosition.set(layoutEntries[index].treePosition, index);
 	const layoutDependenciesByIndex = /* @__PURE__ */ new Map();
+	const renderDependenciesByElementId = /* @__PURE__ */ new Map();
 	const layoutDependenciesBefore = [];
 	const slotDependenciesByLayoutIndex = [];
 	const templateDependenciesById = /* @__PURE__ */ new Map();
@@ -166,7 +205,11 @@ function buildAppPageElements(options) {
 		layoutIds: options.route.ids?.layouts ?? layoutEntries.map((entry) => entry.id),
 		rootLayoutTreePath,
 		routeId,
-		slotBindings: createAppPageSlotBindings(options.route, layoutEntries, resolveSlotOverride)
+		slotBindings: createAppPageSlotBindings(options.route, layoutEntries, resolveSlotOverride, {
+			interception: renderIdentity?.interception ?? options.interception ?? null,
+			interceptionContext,
+			routePath: options.routePath
+		})
 	}) };
 	if (options.route.staticSiblings && options.route.staticSiblings.length > 0) elements[APP_STATIC_SIBLINGS_KEY] = options.route.staticSiblings;
 	const getEffectiveSlotParams = (slotKey, slotName) => resolveSlotOverride(slotKey, slotName)?.params ?? options.matchedParams;
@@ -178,6 +221,7 @@ function buildAppPageElements(options) {
 			if (getDefaultExport(layoutEntry.layoutModule)) {
 				const layoutDependency = createAppRenderDependency();
 				layoutDependenciesByIndex.set(layoutIndex, layoutDependency);
+				renderDependenciesByElementId.set(layoutEntry.id, layoutDependency);
 				pageDependencies.push(layoutDependency);
 			}
 			slotDependenciesByLayoutIndex[layoutIndex] = [...pageDependencies];
@@ -211,7 +255,15 @@ function buildAppPageElements(options) {
 		const layoutEntry = layoutEntries[index];
 		const layoutComponent = getDefaultExport(layoutEntry.layoutModule);
 		if (!layoutComponent) continue;
-		const layoutProps = { params: options.makeThenableParams(resolveAppPageSegmentParams(options.route.routeSegments, layoutEntry.treePosition, options.matchedParams)) };
+		const layoutParams = resolveAppPageSegmentParams(options.route.routeSegments, layoutEntry.treePosition, options.matchedParams);
+		recordLayoutSkipObservationScope({
+			layoutId: layoutEntry.id,
+			layoutModule: layoutEntry.layoutModule,
+			layoutParamAccess: options.layoutParamAccess,
+			routeSegments: options.route.routeSegments,
+			treePosition: layoutEntry.treePosition
+		});
+		const layoutProps = { params: options.makeThenableParams(layoutParams, options.layoutParamAccess?.createThenableParamsObserver(layoutEntry.id)) };
 		for (const slot of Object.values(options.route.slots ?? {})) {
 			const slotName = slot.name;
 			if ((slot.layoutIndex >= 0 ? slot.layoutIndex : layoutEntries.length - 1) !== index) continue;
@@ -245,6 +297,7 @@ function buildAppPageElements(options) {
 		}
 		const slotThenableParams = options.makeThenableParams(slotParams);
 		const slotProps = { params: slotThenableParams };
+		if (options.searchParams !== void 0) slotProps.searchParams = options.searchParams;
 		if (slotOverride?.props) Object.assign(slotProps, slotOverride.props);
 		let slotElement = /* @__PURE__ */ jsx(slotComponent, { ...slotProps });
 		const interceptLayouts = slotOverride?.layoutModules ?? [];
@@ -276,7 +329,7 @@ function buildAppPageElements(options) {
 	}
 	let routeChildren = /* @__PURE__ */ jsx(LayoutSegmentProvider, {
 		segmentMap: { children: [] },
-		children: /* @__PURE__ */ jsx(AppRouterScrollTarget, { children: /* @__PURE__ */ jsx(Slot, { id: pageId }) })
+		children: /* @__PURE__ */ jsx(Slot, { id: pageId })
 	});
 	if (isPrefetchLoadingShell) if (routeLoadingComponent === null) routeChildren = null;
 	else routeChildren = /* @__PURE__ */ jsx(routeLoadingComponent, {});
@@ -286,6 +339,7 @@ function buildAppPageElements(options) {
 			fallback: /* @__PURE__ */ jsx(routeLoadingComponent, {}),
 			children: routeChildren
 		}, routeResetKey);
+		routeChildren = /* @__PURE__ */ jsx(AppRouterScrollTarget, { children: routeChildren });
 	}
 	const lastLayoutErrorModule = errorEntries.length > 0 ? errorEntries[errorEntries.length - 1].errorModule : null;
 	const notFoundComponent = getDefaultExport(options.route.notFound) ?? getDefaultExport(options.rootNotFoundModule);
@@ -381,9 +435,8 @@ function buildAppPageElements(options) {
 		routeChildren,
 		createAppPageRouteBodyMetadata(options.resolvedMetadata, options.resolvedMetadataPathname ?? options.routePath, metadataPlacement)
 	] });
+	registerAppElementRenderDependencies(elements, renderDependenciesByElementId);
 	return elements;
 }
 //#endregion
-export { buildAppPageElements, createAppPageLayoutEntries, createAppPageTreePath, resolveAppPageChildSegments };
-
-//# sourceMappingURL=app-page-route-wiring.js.map
+export { buildAppPageElements, createAppPageLayoutEntries, createAppPageTreePath, probeAppPageLayoutWithTracking, resolveAppPageChildSegments };

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

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

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

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

package/dist/server/app-page-segment-state.d.ts

@@ -6,5 +6,4 @@ declare function resolveAppPageSegmentStateKey(routeSegments: readonly string[],
 declare function resolveAppPageRouteStateKey(routeSegments: readonly string[], params: AppPageParams): string;
 declare function resolveAppPageLeafSegmentStateKey(routeSegments: readonly string[], params: AppPageParams): string;
 //#endregion
-export { resolveAppPageChildSegments, resolveAppPageLeafSegmentStateKey, resolveAppPageRouteStateKey, resolveAppPageSegmentStateKey };
-//# sourceMappingURL=app-page-segment-state.d.ts.map
+export { resolveAppPageChildSegments, resolveAppPageLeafSegmentStateKey, resolveAppPageRouteStateKey, resolveAppPageSegmentStateKey };

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

@@ -1,10 +1,5 @@
+import { isCatchAllSegment, isOptionalCatchAllSegment } from "../routing/utils.js";
 //#region src/server/app-page-segment-state.ts
-function isOptionalCatchAllSegment(segment) {
-	return segment.startsWith("[[...") && segment.endsWith("]]") && segment.length > 7;
-}
-function isCatchAllSegment(segment) {
-	return segment.startsWith("[...") && segment.endsWith("]") && segment.length > 5;
-}
 function isDynamicSegment(segment) {
 	return segment.startsWith("[") && segment.endsWith("]") && !segment.includes(".");
 }
@@ -83,5 +78,3 @@ function resolveAppPageLeafSegmentStateKey(routeSegments, params) {
 }
 //#endregion
 export { resolveAppPageChildSegments, resolveAppPageLeafSegmentStateKey, resolveAppPageRouteStateKey, resolveAppPageSegmentStateKey };
-
-//# sourceMappingURL=app-page-segment-state.js.map

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

@@ -1,3 +1,4 @@
+import { NavigationContext } from "../shims/navigation.js";
 import { AppPageFontPreload } from "./app-page-execution.js";
 import { RootParams } from "../shims/root-params.js";
 import { ReactFormState } from "react-dom/client";
@@ -13,8 +14,36 @@ type CreateAppPageFontDataOptions = {
   getPreloads: () => AppPageFontPreload[];
   getStyles: () => string[];
 };
+type AppSsrRenderResult = {
+  htmlStream: ReadableStream<Uint8Array>;
+  metadataReady: Promise<void>;
+  capturedRscData: Promise<ArrayBuffer> | null;
+  /**
+   * Preload `Link` header value emitted by React during SSR (via `onHeaders`),
+   * already capped to `reactMaxHeadersLength`. Empty/undefined when React
+   * emitted no preload headers (or emission was disabled with `0`).
+   */
+  linkHeader?: string;
+};
+declare function isAppSsrRenderResult(value: unknown): value is AppSsrRenderResult;
+/**
+ * Combine the React-emitted preload `Link` header with vinext's font preload
+ * `Link` header, capping the result to `reactMaxHeadersLength`.
+ *
+ * React already caps its own portion, but vinext emits font preloads through a
+ * separate channel. Mirroring Next.js — where every preload flows through a
+ * single capped `onHeaders` callback — we cap the *combined* header here,
+ * keeping only whole entries that fit and dropping the rest once the limit is
+ * exceeded. `0` disables emission entirely (matches React); `undefined` falls
+ * back to the React default of 6000.
+ *
+ * React's hints (scripts/modules/styles) come first so that under a tight cap
+ * the render-critical entries survive and trailing font preloads are dropped
+ * first.
+ */
+declare function buildAppPageLinkHeader(reactLinkHeader: string | undefined, fontLinkHeader: string | undefined, maxHeadersLength: number | undefined): string;
 type AppPageSsrHandler = {
-  handleSsr: (rscStream: ReadableStream<Uint8Array>, navigationContext: unknown, fontData: AppPageFontData, options?: {
+  handleSsr: (rscStream: ReadableStream<Uint8Array>, navigationContext: NavigationContext | null, fontData: AppPageFontData, options?: {
     formState?: ReactFormState | null;
     scriptNonce?: string;
     basePath?: string;
@@ -23,18 +52,25 @@ type AppPageSsrHandler = {
      * in the SSR head. Sourced from `experimental.clientTraceMetadata`.
      */
     clientTraceMetadata?: readonly string[];
+    /**
+     * Maximum total length (in characters) of the preload `Link` header
+     * emitted during SSR. `0` disables emission. From `reactMaxHeadersLength`
+     * in `next.config`.
+     */
+    reactMaxHeadersLength?: number;
     rootParams?: RootParams;
     sideStream?: ReadableStream<Uint8Array>;
     capturedRscDataRef?: {
       value: Promise<ArrayBuffer> | null;
     }; /** When true, wait for the full React tree before emitting bytes. */
-    waitForAllReady?: boolean;
-  }) => Promise<ReadableStream<Uint8Array>>;
+    waitForAllReady?: boolean; /** Dev-only: original server error to surface in the browser overlay. */
+    initialDevServerError?: unknown;
+  }) => Promise<ReadableStream<Uint8Array> | AppSsrRenderResult>;
 };
 type RenderAppPageHtmlStreamOptions = {
   fontData: AppPageFontData;
   formState?: ReactFormState | null;
-  navigationContext: unknown;
+  navigationContext: NavigationContext | null;
   rscStream: ReadableStream<Uint8Array>;
   scriptNonce?: string;
   basePath?: string;
@@ -44,6 +80,12 @@ type RenderAppPageHtmlStreamOptions = {
    * the SSR head. Undefined or empty disables emission.
    */
   clientTraceMetadata?: readonly string[];
+  /**
+   * Maximum total length (in characters) of the preload `Link` header emitted
+   * during SSR. `0` disables emission. From `reactMaxHeadersLength` in
+   * `next.config`.
+   */
+  reactMaxHeadersLength?: number;
   rootParams?: RootParams;
   ssrHandler: AppPageSsrHandler;
   /** Pre-split side stream for fused embed+capture (#981). When set,
@@ -52,7 +94,8 @@ type RenderAppPageHtmlStreamOptions = {
   capturedRscDataRef?: {
     value: Promise<ArrayBuffer> | null;
   }; /** When true, wait for the full React tree before emitting bytes. */
-  waitForAllReady?: boolean;
+  waitForAllReady?: boolean; /** Dev-only: original server error to surface in the browser overlay. */
+  initialDevServerError?: unknown;
 };
 type RenderAppPageHtmlResponseOptions = {
   clearRequestContext: () => void;
@@ -64,11 +107,14 @@ type RenderAppPageHtmlResponseOptions = {
 type AppPageHtmlStreamRecoveryResult = {
   htmlStream: ReadableStream<Uint8Array> | null;
   response: Response | null;
+  metadataReady: Promise<void>;
+  capturedRscData: Promise<ArrayBuffer> | null; /** React-emitted preload `Link` header (already capped). */
+  linkHeader?: string;
 };
 type RenderAppPageHtmlStreamWithRecoveryOptions<TSpecialError> = {
   onShellRendered?: () => void;
   renderErrorBoundaryResponse: (error: unknown) => Promise<Response | null>;
-  renderHtmlStream: () => Promise<ReadableStream<Uint8Array>>;
+  renderHtmlStream: () => Promise<ReadableStream<Uint8Array> | AppSsrRenderResult>;
   renderSpecialErrorResponse: (specialError: TSpecialError) => Promise<Response>;
   resolveSpecialError: (error: unknown) => TSpecialError | null;
 };
@@ -88,7 +134,7 @@ type ShouldRerenderAppPageWithGlobalErrorOptions = {
   hasLocalBoundary: boolean;
 };
 declare function createAppPageFontData(options: CreateAppPageFontDataOptions): AppPageFontData;
-declare function renderAppPageHtmlStream(options: RenderAppPageHtmlStreamOptions): Promise<ReadableStream<Uint8Array>>;
+declare function renderAppPageHtmlStream(options: RenderAppPageHtmlStreamOptions): Promise<AppSsrRenderResult>;
 /**
  * Wraps a stream so that `onFlush` is called when the last byte has been read
  * by the downstream consumer (i.e. when the HTTP layer finishes draining the
@@ -102,5 +148,4 @@ declare function renderAppPageHtmlStreamWithRecovery<TSpecialError>(options: Ren
 declare function createAppPageRscErrorTracker(baseOnError: (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown): AppPageRscErrorTracker;
 declare function shouldRerenderAppPageWithGlobalError(options: ShouldRerenderAppPageWithGlobalErrorOptions): boolean;
 //#endregion
-export { AppPageFontData, AppPageSsrHandler, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery, shouldRerenderAppPageWithGlobalError };
-//# sourceMappingURL=app-page-stream.d.ts.map
+export { AppPageFontData, AppPageSsrHandler, AppSsrRenderResult, buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery, shouldRerenderAppPageWithGlobalError };

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

@@ -2,6 +2,49 @@ import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { applyEdgeRuntimeHeader } from "./app-page-response.js";
 //#region src/server/app-page-stream.ts
+function isAppSsrRenderResult(value) {
+	return typeof value === "object" && value !== null && "htmlStream" in value && "metadataReady" in value;
+}
+const resolvedMetadataReady = Promise.resolve();
+function normalizeAppSsrRenderResult(raw, fallbackCapturedRscData = null) {
+	if (isAppSsrRenderResult(raw)) return raw;
+	return {
+		htmlStream: raw,
+		metadataReady: resolvedMetadataReady,
+		capturedRscData: fallbackCapturedRscData
+	};
+}
+/**
+* Combine the React-emitted preload `Link` header with vinext's font preload
+* `Link` header, capping the result to `reactMaxHeadersLength`.
+*
+* React already caps its own portion, but vinext emits font preloads through a
+* separate channel. Mirroring Next.js — where every preload flows through a
+* single capped `onHeaders` callback — we cap the *combined* header here,
+* keeping only whole entries that fit and dropping the rest once the limit is
+* exceeded. `0` disables emission entirely (matches React); `undefined` falls
+* back to the React default of 6000.
+*
+* React's hints (scripts/modules/styles) come first so that under a tight cap
+* the render-critical entries survive and trailing font preloads are dropped
+* first.
+*/
+function buildAppPageLinkHeader(reactLinkHeader, fontLinkHeader, maxHeadersLength) {
+	const limit = typeof maxHeadersLength === "number" ? maxHeadersLength : 6e3;
+	if (limit <= 0) return "";
+	const entries = [];
+	for (const source of [reactLinkHeader, fontLinkHeader]) {
+		if (!source) continue;
+		for (const entry of source.split(", ")) if (entry.length > 0) entries.push(entry);
+	}
+	let header = "";
+	for (const entry of entries) {
+		const next = header.length === 0 ? entry : `${header}, ${entry}`;
+		if (next.length > limit) break;
+		header = next;
+	}
+	return header;
+}
 function createAppPageFontData(options) {
 	return {
 		links: options.getLinks(),
@@ -15,12 +58,14 @@ async function renderAppPageHtmlStream(options) {
 		scriptNonce: options.scriptNonce,
 		basePath: options.basePath,
 		clientTraceMetadata: options.clientTraceMetadata,
+		reactMaxHeadersLength: options.reactMaxHeadersLength,
 		rootParams: options.rootParams,
 		sideStream: options.sideStream,
 		capturedRscDataRef: options.capturedRscDataRef,
-		waitForAllReady: options.waitForAllReady
+		waitForAllReady: options.waitForAllReady,
+		initialDevServerError: options.initialDevServerError
 	};
-	return options.ssrHandler.handleSsr(options.rscStream, options.navigationContext, options.fontData, ssrOptions);
+	return normalizeAppSsrRenderResult(await options.ssrHandler.handleSsr(options.rscStream, options.navigationContext, options.fontData, ssrOptions), options.capturedRscDataRef?.value ?? null);
 }
 /**
 * Wraps a stream so that `onFlush` is called when the last byte has been read
@@ -58,7 +103,8 @@ function deferUntilStreamConsumed(stream, onFlush) {
 	});
 }
 async function renderAppPageHtmlResponse(options) {
-	const safeStream = deferUntilStreamConsumed(await renderAppPageHtmlStream(options), () => {
+	const { htmlStream } = await renderAppPageHtmlStream(options);
+	const safeStream = deferUntilStreamConsumed(htmlStream, () => {
 		options.clearRequestContext();
 	});
 	const headers = new Headers({
@@ -75,22 +121,29 @@ async function renderAppPageHtmlResponse(options) {
 }
 async function renderAppPageHtmlStreamWithRecovery(options) {
 	try {
-		const htmlStream = await options.renderHtmlStream();
+		const { htmlStream, metadataReady, capturedRscData, linkHeader } = normalizeAppSsrRenderResult(await options.renderHtmlStream());
 		options.onShellRendered?.();
 		return {
 			htmlStream,
-			response: null
+			response: null,
+			metadataReady,
+			capturedRscData,
+			linkHeader
 		};
 	} catch (error) {
 		const specialError = options.resolveSpecialError(error);
 		if (specialError) return {
 			htmlStream: null,
-			response: await options.renderSpecialErrorResponse(specialError)
+			response: await options.renderSpecialErrorResponse(specialError),
+			metadataReady: resolvedMetadataReady,
+			capturedRscData: null
 		};
 		const boundaryResponse = await options.renderErrorBoundaryResponse(error);
 		if (boundaryResponse) return {
 			htmlStream: null,
-			response: boundaryResponse
+			response: boundaryResponse,
+			metadataReady: resolvedMetadataReady,
+			capturedRscData: null
 		};
 		throw error;
 	}
@@ -117,6 +170,4 @@ function shouldRerenderAppPageWithGlobalError(options) {
 	return Boolean(options.capturedError) && !options.hasLocalBoundary;
 }
 //#endregion
-export { createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery, shouldRerenderAppPageWithGlobalError };
-
-//# sourceMappingURL=app-page-stream.js.map
+export { buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery, shouldRerenderAppPageWithGlobalError };

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

@@ -0,0 +1,41 @@
+import { AppMiddlewareContext } from "./app-middleware.js";
+
+//#region src/server/app-pages-bridge.d.ts
+type PagesEntry = {
+  handleApiRoute?: (request: Request, url: string) => Promise<Response> | Response;
+  renderPage?: (request: Request, url: string, query: Record<string, unknown>, parsedUrl: unknown, middlewareRequestHeaders?: Headers | null) => Promise<Response> | Response;
+};
+type RenderPagesFallbackDependencies = {
+  loadPagesEntry: () => Promise<PagesEntry> | PagesEntry;
+  buildRequestHeaders: (requestHeaders: Headers, middlewareRequestHeaders: Headers) => Headers | null;
+  decodePathParams: (pathname: string) => string;
+  applyRouteHandlerMiddlewareContext: (response: Response, middlewareContext: AppMiddlewareContext) => Response;
+  /**
+   * Returns the `__prerender_bypass` Set-Cookie header emitted by a
+   * `draftMode().enable()`/`disable()` call inside middleware, if any. Reading
+   * it clears it. Mirrors how App Router route handlers and page renders surface
+   * the middleware-enabled draft cookie so the same flow works when the request
+   * falls through to a Pages Router route.
+   *
+   * Note: this closes the draft-mode flow for production (Cloudflare Workers /
+   * Node), where middleware runs inline in the same RSC handler context that
+   * builds this fallback. In hybrid *dev*, middleware runs in a separate Vite
+   * Pages SSR runner and `draftMode()` inside middleware is not yet permitted
+   * there (it throws a scope error before any cookie is set), so this getter
+   * returns `null` and no cookie is appended. That dev limitation is pre-existing
+   * and tracked separately from #1520.
+   */
+  getDraftModeCookieHeader: () => string | null | undefined;
+};
+type RenderPagesFallbackOptions = {
+  isRscRequest: boolean;
+  middlewareContext: AppMiddlewareContext;
+  request: Request;
+  url: URL;
+};
+/**
+ * Fallback handler to route App Router requests to the Pages Router when no App Router route matches.
+ */
+declare function renderPagesFallback(options: RenderPagesFallbackOptions, dependencies: RenderPagesFallbackDependencies): Promise<Response | null>;
+//#endregion
+export { PagesEntry, renderPagesFallback };

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

@@ -0,0 +1,54 @@
+//#region src/server/app-pages-bridge.ts
+/**
+* Fallback handler to route App Router requests to the Pages Router when no App Router route matches.
+*/
+async function renderPagesFallback(options, dependencies) {
+	const { isRscRequest, middlewareContext, request, url } = options;
+	const { loadPagesEntry, buildRequestHeaders, decodePathParams, applyRouteHandlerMiddlewareContext, getDraftModeCookieHeader } = dependencies;
+	if (isRscRequest) return null;
+	const pagesEntry = await loadPagesEntry();
+	const pagesRequestHeaders = middlewareContext.requestHeaders ? buildRequestHeaders(request.headers, middlewareContext.requestHeaders) : null;
+	let pagesRequest = request;
+	if (pagesRequestHeaders) {
+		const pagesRequestInit = {
+			method: request.method,
+			headers: pagesRequestHeaders
+		};
+		if (request.method !== "GET" && request.method !== "HEAD") {
+			pagesRequestInit.body = request.body;
+			pagesRequestInit.duplex = "half";
+		}
+		pagesRequest = new Request(request.url, pagesRequestInit);
+	}
+	const pagesUrl = decodePathParams(url.pathname) + (url.search || "");
+	const pagesPathname = url.pathname;
+	if (pagesPathname.startsWith("/api/") || pagesPathname === "/api") {
+		if (typeof pagesEntry.handleApiRoute !== "function") return null;
+		const pagesApiResponse = await pagesEntry.handleApiRoute(pagesRequest, pagesUrl);
+		const draftCookie = getDraftModeCookieHeader();
+		return applyDraftModeCookie(applyRouteHandlerMiddlewareContext(pagesApiResponse, middlewareContext), draftCookie);
+	}
+	if (typeof pagesEntry.renderPage !== "function") return null;
+	const pagesRes = await pagesEntry.renderPage(pagesRequest, pagesUrl, {}, void 0, middlewareContext.requestHeaders);
+	if (pagesRes.status === 404) return null;
+	return applyDraftModeCookie(pagesRes, getDraftModeCookieHeader());
+}
+/**
+* Append a middleware-emitted `__prerender_bypass` Set-Cookie header to a Pages
+* Router fallback response. Returns the response unchanged when there is no
+* draft cookie to add. App Router route handlers/page renders surface this same
+* cookie via `finalizeRouteHandlerResponse`/the page response builder; this
+* keeps draft-mode parity for requests that fall through to the Pages Router.
+*/
+function applyDraftModeCookie(response, draftCookie) {
+	if (!draftCookie) return response;
+	const headers = new Headers(response.headers);
+	headers.append("Set-Cookie", draftCookie);
+	return new Response(response.body, {
+		status: response.status,
+		statusText: response.statusText,
+		headers
+	});
+}
+//#endregion
+export { renderPagesFallback };

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

@@ -12,5 +12,4 @@ import { RequestContext } from "../config/config-matchers.js";
  */
 declare function buildPostMwRequestContext(request: Request): RequestContext;
 //#endregion
-export { buildPostMwRequestContext };
-//# sourceMappingURL=app-post-middleware-context.d.ts.map
+export { buildPostMwRequestContext };

package/dist/server/app-post-middleware-context.js

@@ -24,5 +24,3 @@ function buildPostMwRequestContext(request) {
 }
 //#endregion
 export { buildPostMwRequestContext };
-
-//# sourceMappingURL=app-post-middleware-context.js.map

package/dist/server/app-ppr-fallback-shell.d.ts

@@ -0,0 +1,21 @@
+//#region src/server/app-ppr-fallback-shell.d.ts
+type AppPprFallbackShellRoute = {
+  params: readonly string[];
+  pattern: string;
+  rootParamNames?: readonly string[] | null;
+};
+type AppPprFallbackShell = {
+  fallbackParamNames: readonly string[];
+  pathname: string;
+  params: Record<string, string | string[]>;
+};
+declare function createAppPprFallbackShell(route: AppPprFallbackShellRoute, matchedParams: Record<string, string | string[]>): AppPprFallbackShell | null;
+declare function createAppPprFallbackShells(route: AppPprFallbackShellRoute, matchedParams: Record<string, string | string[]>): AppPprFallbackShell[];
+declare function rewriteAppPprFallbackShellHtmlNavigation(options: {
+  html: string;
+  params: Record<string, string | string[]>;
+  pathname: string;
+  searchParams: URLSearchParams;
+}): string;
+//#endregion
+export { createAppPprFallbackShell, createAppPprFallbackShells, rewriteAppPprFallbackShellHtmlNavigation };