@qzsy/vinext 0.1.7

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

@@ -0,0 +1,80 @@
+import { isCatchAllSegment, isOptionalCatchAllSegment } from "../routing/utils.js";
+//#region src/server/app-page-segment-state.ts
+function isDynamicSegment(segment) {
+	return segment.startsWith("[") && segment.endsWith("]") && !segment.includes(".");
+}
+function isRouteGroupSegment(segment) {
+	return segment.startsWith("(") && segment.endsWith(")");
+}
+function formatParamSegmentValue(value) {
+	if (Array.isArray(value)) return value.join("/");
+	return value;
+}
+function readSegmentParam(segment) {
+	if (isOptionalCatchAllSegment(segment)) return {
+		name: segment.slice(5, -2),
+		type: "oc"
+	};
+	if (isCatchAllSegment(segment)) return {
+		name: segment.slice(4, -1),
+		type: "c"
+	};
+	if (isDynamicSegment(segment)) return {
+		name: segment.slice(1, -1),
+		type: "d"
+	};
+	return null;
+}
+function formatSegmentStateParamValue(param, params, fallbackSegment) {
+	const value = params[param.name];
+	if (param.type === "oc" && (value === void 0 || Array.isArray(value) && value.length === 0)) return "";
+	return formatParamSegmentValue(value) ?? fallbackSegment;
+}
+function resolveSingleSegmentStateKey(segment, params) {
+	const param = readSegmentParam(segment);
+	if (!param) return segment;
+	return `${param.name}|${formatSegmentStateParamValue(param, params, segment)}|${param.type}`;
+}
+function resolveAppPageChildSegments(routeSegments, treePosition, params) {
+	const rawSegments = routeSegments.slice(treePosition);
+	const resolvedSegments = [];
+	for (const segment of rawSegments) {
+		if (isOptionalCatchAllSegment(segment)) {
+			const paramValue = params[segment.slice(5, -2)];
+			if (Array.isArray(paramValue) && paramValue.length === 0) continue;
+			const resolvedValue = formatParamSegmentValue(paramValue);
+			if (resolvedValue !== void 0) resolvedSegments.push(resolvedValue);
+			continue;
+		}
+		if (isCatchAllSegment(segment)) {
+			const paramName = segment.slice(4, -1);
+			resolvedSegments.push(formatParamSegmentValue(params[paramName]) ?? segment);
+			continue;
+		}
+		if (isDynamicSegment(segment)) {
+			const paramName = segment.slice(1, -1);
+			resolvedSegments.push(formatParamSegmentValue(params[paramName]) ?? segment);
+			continue;
+		}
+		resolvedSegments.push(segment);
+	}
+	return resolvedSegments;
+}
+function resolveAppPageSegmentStateKey(routeSegments, treePosition, params) {
+	for (const segment of routeSegments.slice(treePosition)) if (!isRouteGroupSegment(segment)) return resolveSingleSegmentStateKey(segment, params);
+	return "";
+}
+function resolveAppPageRouteStateKey(routeSegments, params) {
+	const statePath = [];
+	for (const segment of routeSegments) if (!isRouteGroupSegment(segment)) statePath.push(resolveSingleSegmentStateKey(segment, params));
+	return statePath.length > 0 ? JSON.stringify(statePath) : "";
+}
+function resolveAppPageLeafSegmentStateKey(routeSegments, params) {
+	for (let treePosition = routeSegments.length - 1; treePosition >= 0; treePosition--) {
+		const segmentStateKey = resolveAppPageSegmentStateKey(routeSegments, treePosition, params);
+		if (segmentStateKey) return segmentStateKey;
+	}
+	return "";
+}
+//#endregion
+export { resolveAppPageChildSegments, resolveAppPageLeafSegmentStateKey, resolveAppPageRouteStateKey, resolveAppPageSegmentStateKey };

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

@@ -0,0 +1,151 @@
+import { NavigationContext } from "../shims/navigation-context-state.js";
+import { AppPageFontPreload } from "./app-page-execution.js";
+import { RootParams } from "../shims/root-params.js";
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.js";
+import { ReactFormState } from "react-dom/client";
+
+//#region src/server/app-page-stream.d.ts
+type AppPageFontData = {
+  links: string[];
+  preloads: readonly AppPageFontPreload[];
+  styles: string[];
+};
+type CreateAppPageFontDataOptions = {
+  getLinks: () => string[];
+  getPreloads: () => AppPageFontPreload[];
+  getStyles: () => string[];
+};
+type AppSsrRenderResult = {
+  htmlStream: ReadableStream<Uint8Array>;
+  metadataReady: Promise<void>;
+  capturedRscData: Promise<ArrayBuffer> | null;
+  shellErrorRecovered?: boolean;
+  /**
+   * 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: NavigationContext | null, fontData: AppPageFontData, options?: {
+    formState?: ReactFormState | null;
+    scriptNonce?: string;
+    basePath?: string;
+    /**
+     * Allow-list of OpenTelemetry propagation keys to emit as `<meta>` tags
+     * 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;
+    }; /** Abort signal for a build-time PPR fallback-shell static render. */
+    pprFallbackShellSignal?: AbortSignal; /** When true, wait for the full React tree before emitting bytes. */
+    waitForAllReady?: boolean; /** Dev-only: original server error to surface in the browser overlay. */
+    initialDevServerError?: unknown;
+    /** When true, an SSR-phase-only shell render error resolves to the
+     *  default `__next_error__` error-document shell (with the original
+     *  flight payload and bootstrap) instead of rejecting. See handleSsr. */
+    fallbackToErrorDocumentOnShellError?: boolean;
+  }) => Promise<ReadableStream<Uint8Array> | AppSsrRenderResult>;
+};
+type RenderAppPageHtmlStreamOptions = {
+  fontData: AppPageFontData;
+  formState?: ReactFormState | null;
+  navigationContext: NavigationContext | null;
+  rscStream: ReadableStream<Uint8Array>;
+  scriptNonce?: string;
+  basePath?: string;
+  /**
+   * Allow-list of OpenTelemetry propagation keys (from
+   * `experimental.clientTraceMetadata`) to surface as `<meta>` tags in
+   * 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,
+   *  handleSsr skips its internal tee and accumulates raw RSC bytes. */
+  sideStream?: ReadableStream<Uint8Array>; /** Out-parameter filled with accumulated raw RSC bytes after stream consumption. */
+  capturedRscDataRef?: {
+    value: Promise<ArrayBuffer> | null;
+  }; /** Abort signal for a build-time PPR fallback-shell static render. */
+  pprFallbackShellSignal?: AbortSignal; /** When true, wait for the full React tree before emitting bytes. */
+  waitForAllReady?: boolean; /** Dev-only: original server error to surface in the browser overlay. */
+  initialDevServerError?: unknown;
+  /** True when the app supplies a custom global-error.tsx. Disables the
+   *  default error-document shell fallback so SSR shell errors keep driving
+   *  the server-rendered global-error boundary re-render. */
+  hasCustomGlobalError?: boolean;
+};
+type RenderAppPageHtmlResponseOptions = {
+  clearRequestContext: () => void;
+  fontLinkHeader?: string;
+  isEdgeRuntime?: boolean;
+  middlewareHeaders?: Headers | null;
+  status: number;
+} & RenderAppPageHtmlStreamOptions;
+type AppPageHtmlStreamRecoveryResult = {
+  htmlStream: ReadableStream<Uint8Array> | null;
+  response: Response | null;
+  metadataReady: Promise<void>;
+  capturedRscData: Promise<ArrayBuffer> | null;
+  shellErrorRecovered: boolean; /** React-emitted preload `Link` header (already capped). */
+  linkHeader?: string;
+};
+type RenderAppPageHtmlStreamWithRecoveryOptions<TSpecialError> = {
+  onShellRendered?: () => void;
+  renderErrorBoundaryResponse: (error: unknown) => Promise<Response | null>;
+  renderHtmlStream: () => Promise<ReadableStream<Uint8Array> | AppSsrRenderResult>;
+  renderSpecialErrorResponse: (specialError: TSpecialError) => Promise<Response>;
+  resolveSpecialError: (error: unknown) => TSpecialError | null;
+};
+type AppPageRscErrorTracker = {
+  getCapturedError: () => unknown;
+  /**
+   * Returns a NEXT_REDIRECT or NEXT_HTTP_ERROR_FALLBACK error captured during
+   * the RSC render. Read after the SSR shell promise resolves to swap a
+   * 307/404 in place of the streamed body when redirect()/notFound() throws
+   * synchronously inside a route-level Suspense boundary (loading.tsx).
+   */
+  getCapturedSpecialError: () => unknown;
+  onRenderError: (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown;
+};
+declare function createAppPageFontData(options: CreateAppPageFontDataOptions): AppPageFontData;
+declare function renderAppPageHtmlStream(options: RenderAppPageHtmlStreamOptions): Promise<AppSsrRenderResult>;
+declare function renderAppPageHtmlResponse(options: RenderAppPageHtmlResponseOptions): Promise<Response>;
+declare function renderAppPageHtmlStreamWithRecovery<TSpecialError>(options: RenderAppPageHtmlStreamWithRecoveryOptions<TSpecialError>): Promise<AppPageHtmlStreamRecoveryResult>;
+declare function createAppPageRscErrorTracker(baseOnError: (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown): AppPageRscErrorTracker;
+//#endregion
+export { AppPageFontData, AppPageSsrHandler, AppSsrRenderResult, buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery };

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

@@ -0,0 +1,143 @@
+import { isNavigationSignalError } from "../utils/navigation-signal.js";
+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";
+import { deferUntilStreamConsumed } from "./defer-until-stream-consumed.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,
+		shellErrorRecovered: false
+	};
+}
+/**
+* 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(),
+		preloads: options.getPreloads(),
+		styles: options.getStyles()
+	};
+}
+async function renderAppPageHtmlStream(options) {
+	const ssrOptions = {
+		formState: options.formState ?? null,
+		scriptNonce: options.scriptNonce,
+		basePath: options.basePath,
+		clientTraceMetadata: options.clientTraceMetadata,
+		reactMaxHeadersLength: options.reactMaxHeadersLength,
+		rootParams: options.rootParams,
+		sideStream: options.sideStream,
+		capturedRscDataRef: options.capturedRscDataRef,
+		pprFallbackShellSignal: options.pprFallbackShellSignal,
+		waitForAllReady: options.waitForAllReady,
+		initialDevServerError: options.initialDevServerError,
+		fallbackToErrorDocumentOnShellError: options.waitForAllReady !== true && options.hasCustomGlobalError === false
+	};
+	return normalizeAppSsrRenderResult(await options.ssrHandler.handleSsr(options.rscStream, options.navigationContext, options.fontData, ssrOptions), options.capturedRscDataRef?.value ?? null);
+}
+async function renderAppPageHtmlResponse(options) {
+	const { htmlStream } = await renderAppPageHtmlStream(options);
+	const safeStream = deferUntilStreamConsumed(htmlStream, () => {
+		options.clearRequestContext();
+	});
+	const headers = new Headers({
+		"Content-Type": "text/html; charset=utf-8",
+		Vary: VINEXT_RSC_VARY_HEADER
+	});
+	applyEdgeRuntimeHeader(headers, options.isEdgeRuntime);
+	if (options.fontLinkHeader) headers.set("Link", options.fontLinkHeader);
+	mergeMiddlewareResponseHeaders(headers, options.middlewareHeaders ?? null);
+	return new Response(safeStream, {
+		status: options.status,
+		headers
+	});
+}
+async function renderAppPageHtmlStreamWithRecovery(options) {
+	try {
+		const { htmlStream, metadataReady, capturedRscData, linkHeader, shellErrorRecovered } = normalizeAppSsrRenderResult(await options.renderHtmlStream());
+		options.onShellRendered?.();
+		return {
+			htmlStream,
+			response: null,
+			metadataReady,
+			capturedRscData,
+			shellErrorRecovered: shellErrorRecovered === true,
+			linkHeader
+		};
+	} catch (error) {
+		const specialError = options.resolveSpecialError(error);
+		if (specialError) return {
+			htmlStream: null,
+			response: await options.renderSpecialErrorResponse(specialError),
+			metadataReady: resolvedMetadataReady,
+			capturedRscData: null,
+			shellErrorRecovered: false
+		};
+		const boundaryResponse = await options.renderErrorBoundaryResponse(error);
+		if (boundaryResponse) return {
+			htmlStream: null,
+			response: boundaryResponse,
+			metadataReady: resolvedMetadataReady,
+			capturedRscData: null,
+			shellErrorRecovered: false
+		};
+		throw error;
+	}
+}
+function createAppPageRscErrorTracker(baseOnError) {
+	let capturedError = null;
+	let capturedSpecialError = null;
+	return {
+		getCapturedError() {
+			return capturedError;
+		},
+		getCapturedSpecialError() {
+			return capturedSpecialError;
+		},
+		onRenderError(error, requestInfo, errorContext) {
+			if (isNavigationSignalError(error)) {
+				if (capturedSpecialError === null) capturedSpecialError = error;
+			} else capturedError = error;
+			return baseOnError(error, requestInfo, errorContext);
+		}
+	};
+}
+//#endregion
+export { buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery };

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

@@ -0,0 +1,63 @@
+import { AppMiddlewareContext } from "./app-middleware.js";
+
+//#region src/server/app-pages-bridge.d.ts
+type PagesEntry = {
+  handleApiRoute?: (request: Request, url: 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?: {
+    isDataReq?: boolean;
+  }) => Promise<Response> | Response;
+};
+type PagesRouteMatch = {
+  route: {
+    isDynamic: boolean;
+    pattern: string;
+  };
+};
+type AppRouteMatch = {
+  route: {
+    isDynamic: boolean;
+    pattern: string;
+  };
+};
+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 = {
+  allowRscDocumentFallback?: boolean;
+  appRouteMatch?: AppRouteMatch | null;
+  isDataRequest?: boolean;
+  isRscRequest: boolean;
+  matchKind?: "dynamic" | "static";
+  middlewareContext: AppMiddlewareContext;
+  pathname?: string;
+  pagesDataRequest?: Request | null;
+  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,63 @@
+import { cloneRequestWithHeaders, cloneRequestWithUrl } from "./request-pipeline.js";
+import { pagesRouteHasPriorityOverAppRoute } from "./hybrid-route-priority.js";
+//#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 { allowRscDocumentFallback = false, appRouteMatch = null, isDataRequest = false, isRscRequest, matchKind, middlewareContext, pathname = options.url.pathname, pagesDataRequest = null, request, url } = options;
+	const { loadPagesEntry, buildRequestHeaders, decodePathParams, applyRouteHandlerMiddlewareContext, getDraftModeCookieHeader } = dependencies;
+	if (isRscRequest && !allowRscDocumentFallback) return null;
+	const pagesEntry = await loadPagesEntry();
+	const pagesRequestHeaders = middlewareContext.requestHeaders ? buildRequestHeaders(request.headers, middlewareContext.requestHeaders) : null;
+	let pagesRequest = request;
+	if (pagesRequestHeaders) pagesRequest = cloneRequestWithHeaders(request, pagesRequestHeaders);
+	const queryIndex = pathname.indexOf("?");
+	const pagesPathname = queryIndex === -1 ? pathname : pathname.slice(0, queryIndex);
+	const pagesSearch = queryIndex === -1 ? url.search || "" : pathname.slice(queryIndex);
+	const pagesUrl = decodePathParams(pagesPathname) + pagesSearch;
+	if (pagesPathname.startsWith("/api/") || pagesPathname === "/api") {
+		if (typeof pagesEntry.handleApiRoute !== "function") return null;
+		const hasApiMatcher = typeof pagesEntry.matchApiRoute === "function";
+		const apiMatch = hasApiMatcher ? pagesEntry.matchApiRoute?.(pagesUrl, pagesRequest) ?? null : null;
+		if (hasApiMatcher && apiMatch === null) return null;
+		if (apiMatch !== null && matchKind === "static" && apiMatch.route.isDynamic) return null;
+		if (apiMatch !== null && matchKind === "dynamic" && !apiMatch.route.isDynamic) return null;
+		if (appRouteMatch !== null) {
+			if (apiMatch === null || !pagesRouteHasPriorityOverAppRoute(apiMatch.route, appRouteMatch.route)) 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 hasPageMatcher = typeof pagesEntry.matchPageRoute === "function";
+	const pageMatch = hasPageMatcher ? pagesEntry.matchPageRoute?.(pagesUrl, pagesRequest) ?? null : null;
+	if (hasPageMatcher && pageMatch === null) return null;
+	if (pageMatch !== null && matchKind === "static" && pageMatch.route.isDynamic) return null;
+	if (pageMatch !== null && matchKind === "dynamic" && !pageMatch.route.isDynamic) return null;
+	if (appRouteMatch !== null && (pageMatch === null || !pagesRouteHasPriorityOverAppRoute(pageMatch.route, appRouteMatch.route))) return null;
+	const renderRequest = pagesDataRequest ? cloneRequestWithUrl(pagesRequest, pagesDataRequest.url) : pagesRequest;
+	const pagesRes = isDataRequest ? await pagesEntry.renderPage(renderRequest, pagesUrl, {}, void 0, middlewareContext.requestHeaders, { isDataReq: true }) : await pagesEntry.renderPage(renderRequest, pagesUrl, {}, void 0, middlewareContext.requestHeaders);
+	if (pagesRes.status === 404 && pageMatch === null) 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

@@ -0,0 +1,15 @@
+import { RequestContext } from "../config/config-matchers.js";
+
+//#region src/server/app-post-middleware-context.d.ts
+/**
+ * Build a request context from the live ALS HeadersContext, which reflects
+ * any x-middleware-request-* header mutations applied by middleware.
+ * Used for afterFiles and fallback rewrite has/missing evaluation — these
+ * run after middleware in the App Router execution order.
+ *
+ * Falls back to `requestContextFromRequest(request)` when no HeadersContext
+ * is set (no middleware ran, or middleware didn't set request headers).
+ */
+declare function buildPostMwRequestContext(request: Request): RequestContext;
+//#endregion
+export { buildPostMwRequestContext };

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

@@ -0,0 +1,26 @@
+import { normalizeHost, requestContextFromRequest } from "../config/config-matchers.js";
+import { getHeadersContext } from "../shims/headers.js";
+//#region src/server/app-post-middleware-context.ts
+/**
+* Build a request context from the live ALS HeadersContext, which reflects
+* any x-middleware-request-* header mutations applied by middleware.
+* Used for afterFiles and fallback rewrite has/missing evaluation — these
+* run after middleware in the App Router execution order.
+*
+* Falls back to `requestContextFromRequest(request)` when no HeadersContext
+* is set (no middleware ran, or middleware didn't set request headers).
+*/
+function buildPostMwRequestContext(request) {
+	const url = new URL(request.url);
+	const ctx = getHeadersContext();
+	if (!ctx) return requestContextFromRequest(request);
+	const cookiesRecord = Object.fromEntries(ctx.cookies);
+	return {
+		headers: ctx.headers,
+		cookies: cookiesRecord,
+		query: url.searchParams,
+		host: normalizeHost(ctx.headers.get("host"), url.hostname)
+	};
+}
+//#endregion
+export { buildPostMwRequestContext };

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

@@ -0,0 +1,18 @@
+import { PprFallbackShellState } from "../shims/ppr-fallback-shell.js";
+import { ReactNode } from "react";
+
+//#region src/server/app-ppr-fallback-shell-render.d.ts
+type AppPageBoundaryOnError = (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown;
+type AppPageRenderableElement = ReactNode | Record<string, ReactNode>;
+type WarmPprFallbackShellCachesOptions = {
+  element: AppPageRenderableElement;
+  onError: AppPageBoundaryOnError;
+  renderToReadableStream: (element: AppPageRenderableElement, options: {
+    onError: AppPageBoundaryOnError;
+    signal?: AbortSignal;
+  }) => ReadableStream<Uint8Array>;
+  state: PprFallbackShellState;
+};
+declare function warmPprFallbackShellCaches(options: WarmPprFallbackShellCachesOptions): Promise<void>;
+//#endregion
+export { WarmPprFallbackShellCachesOptions, warmPprFallbackShellCaches };

package/dist/server/app-ppr-fallback-shell-render.js

@@ -0,0 +1,26 @@
+import { isPprFallbackShellAbortError, preparePprFallbackShellFinalRender, waitForPprFallbackShellCacheReady } from "../shims/ppr-fallback-shell.js";
+import { readAppPageBinaryStream } from "./app-page-execution.js";
+//#region src/server/app-ppr-fallback-shell-render.ts
+async function warmPprFallbackShellCaches(options) {
+	let warmupError = null;
+	const warmupDrain = readAppPageBinaryStream(options.renderToReadableStream(options.element, {
+		signal: options.state.abortController.signal,
+		onError(error, requestInfo, errorContext) {
+			if (options.state.abortController.signal.aborted || isPprFallbackShellAbortError(error)) return;
+			return options.onError(error, requestInfo, errorContext);
+		}
+	})).catch((error) => {
+		if (options.state.abortController.signal.aborted || isPprFallbackShellAbortError(error)) return;
+		warmupError = error;
+	});
+	try {
+		await waitForPprFallbackShellCacheReady(options.state);
+	} finally {
+		options.state.abortController.abort();
+		await warmupDrain;
+		preparePprFallbackShellFinalRender(options.state);
+	}
+	if (warmupError) throw warmupError;
+}
+//#endregion
+export { warmPprFallbackShellCaches };

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

@@ -0,0 +1,33 @@
+//#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[]>;
+};
+/**
+ * A fallback-shell cache entry as consumed by the dispatch layer.
+ * Produced at build time by the PPR prerender and served at request time
+ * when the exact cache entry for a dynamic child param is missing.
+ */
+type AppPagePprFallbackCacheShell = {
+  fallbackParamNames: readonly string[];
+  params: Record<string, string | string[]>;
+  pathname: string;
+};
+declare function markAppPprDynamicFallbackShellHtml(html: string): string;
+declare function isAppPprDynamicFallbackShellHtml(html: string): boolean;
+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 { AppPagePprFallbackCacheShell, createAppPprFallbackShell, createAppPprFallbackShells, isAppPprDynamicFallbackShellHtml, markAppPprDynamicFallbackShellHtml, rewriteAppPprFallbackShellHtmlNavigation };