vinext 0.1.0 → 0.1.2

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

@@ -6,6 +6,7 @@ type AppPageParams = Record<string, string | string[]>;
 type GenerateStaticParams = (args: {
   params: AppPageParams;
 }) => unknown;
+type Awaitable<T> = T | Promise<T>;
 type GenerateStaticParamsModule = {
   generateStaticParams?: GenerateStaticParams | null;
 };
@@ -39,6 +40,7 @@ type BuildAppPageElementResult<TElement> = {
 type AppPageInterceptMatch<TPage = unknown> = {
   matchedParams: AppPageParams;
   page: TPage;
+  __pageLoader?: (() => Promise<TPage>) | null;
   slotId?: string | null;
   slotKey: string;
   sourceRouteIndex: number;
@@ -48,7 +50,7 @@ type ResolveAppPageInterceptMatchOptions<TRoute, TPage, TInterceptOpts> = {
   currentRoute: TRoute;
   findIntercept: (pathname: string) => AppPageInterceptMatch<TPage> | null;
   getRouteParamNames: (route: TRoute) => readonly string[];
-  getSourceRoute: (sourceRouteIndex: number) => TRoute | undefined;
+  getSourceRoute: (sourceRouteIndex: number) => Awaitable<TRoute | undefined>;
   isRscRequest: boolean;
   toInterceptOpts: (intercept: AppPageInterceptMatch<TPage>) => TInterceptOpts;
 };
@@ -64,7 +66,7 @@ type ResolveAppPageInterceptionRerenderTargetOptions<TRoute, TPage, TInterceptOp
   currentRoute: TRoute;
   findIntercept: (pathname: string) => AppPageInterceptMatch<TPage> | null;
   getRouteParamNames: (route: TRoute) => readonly string[];
-  getSourceRoute: (sourceRouteIndex: number) => TRoute | undefined;
+  getSourceRoute: (sourceRouteIndex: number) => Awaitable<TRoute | undefined>;
   isRscRequest: boolean;
   toInterceptOpts: (intercept: AppPageInterceptMatch<TPage>) => TInterceptOpts;
 };
@@ -82,9 +84,10 @@ type ResolveAppPageInterceptOptions<TRoute, TPage, TInterceptOpts, TElement> = {
   currentRoute: TRoute;
   findIntercept: (pathname: string) => AppPageInterceptMatch<TPage> | null;
   getRouteParamNames: (route: TRoute) => readonly string[];
-  getSourceRoute: (sourceRouteIndex: number) => TRoute | undefined;
+  getSourceRoute: (sourceRouteIndex: number) => Awaitable<TRoute | undefined>;
   isRscRequest: boolean;
   layoutParamAccess?: AppLayoutParamAccessTracker;
+  resolveNavigationParams: (route: TRoute, params: AppPageParams, pathname: string, interceptOpts: TInterceptOpts) => AppPageParams;
   renderInterceptResponse: (route: TRoute, element: TElement) => Promise<Response> | Response;
   searchParams: URLSearchParams;
   setNavigationContext: (context: {
@@ -116,9 +119,9 @@ declare function validateAppPageDynamicParams(options: ValidateAppPageDynamicPar
  * `setNavigationContext` + element build + Response wrap) and the server-action
  * POST path (entries/app-rsc-entry.ts), which runs its own response pipeline.
  */
-declare function resolveAppPageInterceptMatch<TRoute, TPage, TInterceptOpts>(options: ResolveAppPageInterceptMatchOptions<TRoute, TPage, TInterceptOpts>): ResolveAppPageInterceptMatchResult<TRoute, TInterceptOpts> | null;
-declare function resolveAppPageInterceptionRerenderTarget<TRoute, TPage, TInterceptOpts>(options: ResolveAppPageInterceptionRerenderTargetOptions<TRoute, TPage, TInterceptOpts>): ResolveAppPageInterceptionRerenderTargetResult<TRoute, TInterceptOpts>;
-declare function resolveAppPageActionRerenderTarget<TRoute, TPage, TInterceptOpts>(options: ResolveAppPageActionRerenderTargetOptions<TRoute, TPage, TInterceptOpts>): ResolveAppPageActionRerenderTargetResult<TRoute, TInterceptOpts>;
+declare function resolveAppPageInterceptMatch<TRoute, TPage, TInterceptOpts>(options: ResolveAppPageInterceptMatchOptions<TRoute, TPage, TInterceptOpts>): Promise<ResolveAppPageInterceptMatchResult<TRoute, TInterceptOpts> | null>;
+declare function resolveAppPageInterceptionRerenderTarget<TRoute, TPage, TInterceptOpts>(options: ResolveAppPageInterceptionRerenderTargetOptions<TRoute, TPage, TInterceptOpts>): Promise<ResolveAppPageInterceptionRerenderTargetResult<TRoute, TInterceptOpts>>;
+declare function resolveAppPageActionRerenderTarget<TRoute, TPage, TInterceptOpts>(options: ResolveAppPageActionRerenderTargetOptions<TRoute, TPage, TInterceptOpts>): Promise<ResolveAppPageActionRerenderTargetResult<TRoute, TInterceptOpts>>;
 declare function resolveAppPageIntercept<TRoute, TPage, TInterceptOpts, TElement>(options: ResolveAppPageInterceptOptions<TRoute, TPage, TInterceptOpts, TElement>): Promise<ResolveAppPageInterceptResult<TInterceptOpts>>;
 declare function buildAppPageElement<TElement>(options: BuildAppPageElementOptions<TElement>): Promise<BuildAppPageElementResult<TElement>>;
 //#endregion

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

@@ -90,8 +90,8 @@ async function validateAppPageDynamicParams(options) {
 * `setNavigationContext` + element build + Response wrap) and the server-action
 * POST path (entries/app-rsc-entry.ts), which runs its own response pipeline.
 */
-function resolveAppPageInterceptMatch(options) {
-	const interceptState = resolveAppPageInterceptState(options);
+async function resolveAppPageInterceptMatch(options) {
+	const interceptState = await resolveAppPageInterceptState(options);
 	if (interceptState.kind !== "source-route") return null;
 	return {
 		interceptOpts: options.toInterceptOpts(interceptState.intercept),
@@ -100,11 +100,12 @@ function resolveAppPageInterceptMatch(options) {
 		sourceRoute: interceptState.sourceRoute
 	};
 }
-function resolveAppPageInterceptState(options) {
+async function resolveAppPageInterceptState(options) {
 	if (!options.isRscRequest) return { kind: "none" };
 	const intercept = options.findIntercept(options.cleanPathname);
 	if (!intercept) return { kind: "none" };
-	const sourceRoute = options.getSourceRoute(intercept.sourceRouteIndex);
+	if (intercept.__pageLoader && intercept.page == null) intercept.page = await intercept.__pageLoader();
+	const sourceRoute = await options.getSourceRoute(intercept.sourceRouteIndex);
 	if (!sourceRoute) return { kind: "none" };
 	if (sourceRoute === options.currentRoute) return {
 		kind: "current-route",
@@ -116,8 +117,8 @@ function resolveAppPageInterceptState(options) {
 		sourceRoute
 	};
 }
-function resolveAppPageInterceptionRerenderTarget(options) {
-	const interceptState = resolveAppPageInterceptState({
+async function resolveAppPageInterceptionRerenderTarget(options) {
+	const interceptState = await resolveAppPageInterceptState({
 		cleanPathname: options.cleanPathname,
 		currentRoute: options.currentRoute,
 		findIntercept: options.findIntercept,
@@ -143,7 +144,7 @@ function resolveAppPageActionRerenderTarget(options) {
 	return resolveAppPageInterceptionRerenderTarget(options);
 }
 async function resolveAppPageIntercept(options) {
-	const interceptState = resolveAppPageInterceptState({
+	const interceptState = await resolveAppPageInterceptState({
 		cleanPathname: options.cleanPathname,
 		currentRoute: options.currentRoute,
 		findIntercept: options.findIntercept,
@@ -153,15 +154,18 @@ async function resolveAppPageIntercept(options) {
 		toInterceptOpts: options.toInterceptOpts
 	});
 	if (interceptState.kind === "source-route") {
+		const renderRoute = interceptState.sourceRoute;
+		const interceptOpts = options.toInterceptOpts(interceptState.intercept);
+		const renderParams = pickRouteParams(interceptState.intercept.matchedParams, options.getRouteParamNames(interceptState.sourceRoute));
 		options.setNavigationContext({
-			params: interceptState.intercept.matchedParams,
+			params: options.resolveNavigationParams(renderRoute, interceptState.intercept.matchedParams, options.cleanPathname, interceptOpts),
 			pathname: options.cleanPathname,
 			searchParams: options.searchParams
 		});
-		const interceptElement = await options.buildPageElement(interceptState.sourceRoute, pickRouteParams(interceptState.intercept.matchedParams, options.getRouteParamNames(interceptState.sourceRoute)), options.toInterceptOpts(interceptState.intercept), options.searchParams, options.layoutParamAccess);
+		const interceptElement = await options.buildPageElement(renderRoute, renderParams, interceptOpts, options.searchParams, options.layoutParamAccess);
 		return {
 			interceptOpts: void 0,
-			response: await options.renderInterceptResponse(interceptState.sourceRoute, interceptElement)
+			response: await options.renderInterceptResponse(renderRoute, interceptElement)
 		};
 	}
 	return {

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

@@ -45,8 +45,8 @@ type BuildAppPageRscResponseOptions = {
   timing?: AppPageResponseTiming;
 };
 type BuildAppPageHtmlResponseOptions = {
-  draftCookie?: string | null;
-  fontLinkHeader?: string;
+  draftCookie?: string | null; /** Combined preload `Link` header value (React hints + font preloads), already capped. */
+  linkHeader?: string;
   isEdgeRuntime?: boolean;
   middlewareContext: AppPageMiddlewareContext;
   policy: AppPageResponsePolicy;

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

@@ -1,7 +1,7 @@
 import { VINEXT_DYNAMIC_STALE_TIME_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_PARAMS_HEADER, VINEXT_TIMING_HEADER } from "./headers.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
-import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
 import { NO_STORE_CACHE_CONTROL, STATIC_CACHE_CONTROL, buildRevalidateCacheControl } from "./cache-control.js";
+import { VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 //#region src/server/app-page-response.ts
 function applyTimingHeader(headers, timing) {
@@ -108,7 +108,7 @@ function buildAppPageHtmlResponse(body, options) {
 	if (options.policy.cacheControl) headers.set("Cache-Control", options.policy.cacheControl);
 	if (options.policy.cacheState) setCacheStateHeaders(headers, options.policy.cacheState);
 	if (options.draftCookie) headers.append("Set-Cookie", options.draftCookie);
-	if (options.fontLinkHeader) headers.set("Link", options.fontLinkHeader);
+	if (options.linkHeader) headers.set("Link", options.linkHeader);
 	mergeMiddlewareResponseHeaders(headers, options.middlewareContext.headers);
 	applyTimingHeader(headers, options.timing);
 	return new Response(body, {

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

@@ -113,6 +113,7 @@ type BuildAppPageRouteElementOptions<TModule extends AppPageModule = AppPageModu
   resolvedMetadata: Metadata | null;
   resolvedMetadataPathname?: string;
   resolvedViewport: Viewport;
+  trailingSlash?: boolean;
   rootForbiddenModule?: TModule | null;
   rootNotFoundModule?: TModule | null;
   rootUnauthorizedModule?: TModule | null;
@@ -142,6 +143,7 @@ declare function createAppPageLayoutEntries<TModule extends AppPageModule, TErro
   forbiddens?: readonly (TModule | null | undefined)[] | null;
   unauthorizeds?: readonly (TModule | null | undefined)[] | null;
 }): AppPageLayoutEntry<TModule, TErrorModule>[];
+declare function createAppPageRouteBodyMetadata(metadata: Metadata | null, pathname: string, metadataPlacement: "body" | "head", trailingSlash?: boolean): ReactNode;
 declare function buildAppPageElements<TModule extends AppPageModule, TErrorModule extends AppPageErrorModule>(options: BuildAppPageElementsOptions<TModule, TErrorModule>): AppElements;
 //#endregion
-export { AppPageErrorModule, AppPageModule, AppPageRouteWiringRoute, AppPageSlotOverride, buildAppPageElements, createAppPageLayoutEntries, createAppPageTreePath, probeAppPageLayoutWithTracking, resolveAppPageChildSegments };
+export { AppPageErrorModule, AppPageModule, AppPageRouteWiringRoute, AppPageSlotOverride, buildAppPageElements, createAppPageLayoutEntries, createAppPageRouteBodyMetadata, createAppPageTreePath, probeAppPageLayoutWithTracking, resolveAppPageChildSegments };

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

@@ -139,21 +139,22 @@ function createAppPageSlotBindings(route, layoutEntries, resolveSlotOverride, op
 	}
 	return normalizeAppElementsSlotBindings(bindings, { layoutIds: layoutEntries.map((entry) => entry.id) });
 }
-function createAppPageRouteHead(metadata, viewport, pathname, metadataPlacement) {
+function createAppPageRouteHead(metadata, viewport, pathname, metadataPlacement, trailingSlash) {
 	return /* @__PURE__ */ jsxs(Fragment$1, { children: [
 		/* @__PURE__ */ jsx("meta", { charSet: "utf-8" }),
 		metadata && metadataPlacement === "head" ? /* @__PURE__ */ jsx(MetadataHead, {
 			metadata,
-			pathname
+			pathname,
+			trailingSlash
 		}) : null,
 		/* @__PURE__ */ jsx(ViewportHead, { viewport })
 	] });
 }
-function createAppPageRouteBodyMetadata(metadata, pathname, metadataPlacement) {
+function createAppPageRouteBodyMetadata(metadata, pathname, metadataPlacement, trailingSlash) {
 	if (!metadata || metadataPlacement !== "body") return null;
 	return /* @__PURE__ */ jsx("div", {
 		hidden: true,
-		dangerouslySetInnerHTML: { __html: renderMetadataToHtml(metadata, pathname) }
+		dangerouslySetInnerHTML: { __html: renderMetadataToHtml(metadata, pathname, { trailingSlash }) }
 	});
 }
 function buildAppPageElements(options) {
@@ -329,7 +330,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, {});
@@ -339,6 +340,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);
@@ -430,12 +432,12 @@ function buildAppPageElements(options) {
 		children: routeChildren
 	});
 	elements[routeId] = /* @__PURE__ */ jsxs(Fragment$1, { children: [
-		createAppPageRouteHead(options.resolvedMetadata, options.resolvedViewport, options.resolvedMetadataPathname ?? options.routePath, metadataPlacement),
+		createAppPageRouteHead(options.resolvedMetadata, options.resolvedViewport, options.resolvedMetadataPathname ?? options.routePath, metadataPlacement, options.trailingSlash),
 		routeChildren,
-		createAppPageRouteBodyMetadata(options.resolvedMetadata, options.resolvedMetadataPathname ?? options.routePath, metadataPlacement)
+		createAppPageRouteBodyMetadata(options.resolvedMetadata, options.resolvedMetadataPathname ?? options.routePath, metadataPlacement, options.trailingSlash)
 	] });
 	registerAppElementRenderDependencies(elements, renderDependenciesByElementId);
 	return elements;
 }
 //#endregion
-export { buildAppPageElements, createAppPageLayoutEntries, createAppPageTreePath, probeAppPageLayoutWithTracking, resolveAppPageChildSegments };
+export { buildAppPageElements, createAppPageLayoutEntries, createAppPageRouteBodyMetadata, createAppPageTreePath, probeAppPageLayoutWithTracking, resolveAppPageChildSegments };

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

@@ -18,8 +18,30 @@ 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: NavigationContext | null, fontData: AppPageFontData, options?: {
     formState?: ReactFormState | null;
@@ -30,6 +52,12 @@ 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?: {
@@ -52,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,
@@ -74,7 +108,8 @@ type AppPageHtmlStreamRecoveryResult = {
   htmlStream: ReadableStream<Uint8Array> | null;
   response: Response | null;
   metadataReady: Promise<void>;
-  capturedRscData: Promise<ArrayBuffer> | null;
+  capturedRscData: Promise<ArrayBuffer> | null; /** React-emitted preload `Link` header (already capped). */
+  linkHeader?: string;
 };
 type RenderAppPageHtmlStreamWithRecoveryOptions<TSpecialError> = {
   onShellRendered?: () => void;
@@ -94,10 +129,6 @@ type AppPageRscErrorTracker = {
   getCapturedSpecialError: () => unknown;
   onRenderError: (error: unknown, requestInfo: unknown, errorContext: unknown) => unknown;
 };
-type ShouldRerenderAppPageWithGlobalErrorOptions = {
-  capturedError: unknown;
-  hasLocalBoundary: boolean;
-};
 declare function createAppPageFontData(options: CreateAppPageFontDataOptions): AppPageFontData;
 declare function renderAppPageHtmlStream(options: RenderAppPageHtmlStreamOptions): Promise<AppSsrRenderResult>;
 /**
@@ -111,6 +142,5 @@ declare function deferUntilStreamConsumed(stream: ReadableStream<Uint8Array>, on
 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;
-declare function shouldRerenderAppPageWithGlobalError(options: ShouldRerenderAppPageWithGlobalErrorOptions): boolean;
 //#endregion
-export { AppPageFontData, AppPageSsrHandler, AppSsrRenderResult, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery, shouldRerenderAppPageWithGlobalError };
+export { AppPageFontData, AppPageSsrHandler, AppSsrRenderResult, buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery };

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

@@ -14,6 +14,37 @@ function normalizeAppSsrRenderResult(raw, fallbackCapturedRscData = null) {
 		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(),
@@ -27,6 +58,7 @@ 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,
@@ -89,13 +121,14 @@ async function renderAppPageHtmlResponse(options) {
 }
 async function renderAppPageHtmlStreamWithRecovery(options) {
 	try {
-		const { htmlStream, metadataReady, capturedRscData } = normalizeAppSsrRenderResult(await options.renderHtmlStream());
+		const { htmlStream, metadataReady, capturedRscData, linkHeader } = normalizeAppSsrRenderResult(await options.renderHtmlStream());
 		options.onShellRendered?.();
 		return {
 			htmlStream,
 			response: null,
 			metadataReady,
-			capturedRscData
+			capturedRscData,
+			linkHeader
 		};
 	} catch (error) {
 		const specialError = options.resolveSpecialError(error);
@@ -133,8 +166,5 @@ function createAppPageRscErrorTracker(baseOnError) {
 		}
 	};
 }
-function shouldRerenderAppPageWithGlobalError(options) {
-	return Boolean(options.capturedError) && !options.hasLocalBoundary;
-}
 //#endregion
-export { createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery, shouldRerenderAppPageWithGlobalError };
+export { buildAppPageLinkHeader, createAppPageFontData, createAppPageRscErrorTracker, deferUntilStreamConsumed, isAppSsrRenderResult, renderAppPageHtmlResponse, renderAppPageHtmlStream, renderAppPageHtmlStreamWithRecovery };

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

@@ -10,6 +10,22 @@ type RenderPagesFallbackDependencies = {
   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;

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

@@ -4,7 +4,7 @@
 */
 async function renderPagesFallback(options, dependencies) {
 	const { isRscRequest, middlewareContext, request, url } = options;
-	const { loadPagesEntry, buildRequestHeaders, decodePathParams, applyRouteHandlerMiddlewareContext } = dependencies;
+	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;
@@ -24,11 +24,31 @@ async function renderPagesFallback(options, dependencies) {
 	const pagesPathname = url.pathname;
 	if (pagesPathname.startsWith("/api/") || pagesPathname === "/api") {
 		if (typeof pagesEntry.handleApiRoute !== "function") return null;
-		return applyRouteHandlerMiddlewareContext(await pagesEntry.handleApiRoute(pagesRequest, pagesUrl), middlewareContext);
+		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);
-	return pagesRes.status !== 404 ? pagesRes : null;
+	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-route-handler-cache.d.ts

@@ -18,6 +18,7 @@ type ReadAppRouteHandlerCacheOptions = {
   getCollectedFetchTags: () => string[];
   handlerFn: AppRouteHandlerFunction;
   i18n?: NextI18nConfig | null;
+  trailingSlash?: boolean;
   isAutoHead: boolean;
   isrDebug?: AppRouteDebugLogger;
   isrGet: RouteHandlerCacheGetter;

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

@@ -39,6 +39,7 @@ async function readAppRouteHandlerCacheResponse(options) {
 						dynamicConfig: options.dynamicConfig,
 						handlerFn: options.handlerFn,
 						i18n: options.i18n,
+						trailingSlash: options.trailingSlash,
 						markDynamicUsage: options.markDynamicUsage,
 						params: options.params === null ? null : makeThenableParams(options.params),
 						request: new Request(options.requestUrl, { method: "GET" }),

package/dist/server/app-route-handler-dispatch.d.ts

@@ -30,6 +30,7 @@ type DispatchAppRouteHandlerOptions = {
   isrGet: RouteHandlerCacheGetter;
   isrRouteKey: (pathname: string) => string;
   isrSet: RouteHandlerCacheSetter;
+  trailingSlash?: boolean;
   middlewareContext: RouteHandlerMiddlewareContext;
   middlewareRequestHeaders?: Headers | null;
   /**

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

@@ -77,6 +77,7 @@ async function dispatchAppRouteHandler(options) {
 			getCollectedFetchTags,
 			handlerFn: resolvedHandlerFn,
 			i18n: options.i18n,
+			trailingSlash: options.trailingSlash,
 			isAutoHead,
 			isrDebug: options.isrDebug,
 			isrGet: options.isrGet,
@@ -127,6 +128,7 @@ async function dispatchAppRouteHandler(options) {
 		handler,
 		handlerFn: resolvedHandlerFn,
 		i18n: options.i18n,
+		trailingSlash: options.trailingSlash,
 		isAutoHead,
 		isProduction,
 		isrDebug: options.isrDebug,

package/dist/server/app-route-handler-execution.d.ts

@@ -42,6 +42,7 @@ type RunAppRouteHandlerOptions = {
   dynamicConfig?: string;
   handlerFn: AppRouteHandlerFunction;
   i18n?: NextI18nConfig | null;
+  trailingSlash?: boolean;
   markDynamicUsage: MarkAppRouteDynamicUsageFn;
   middlewareRequestHeaders?: Headers | null;
   /**

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

@@ -21,6 +21,7 @@ async function runAppRouteHandler(options) {
 	const trackedRequest = createTrackedAppRouteRequest(options.request, {
 		basePath: options.basePath,
 		i18n: options.i18n,
+		trailingSlash: options.trailingSlash,
 		middlewareHeaders: options.middlewareRequestHeaders,
 		onDynamicAccess() {
 			options.markDynamicUsage();

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

@@ -1,7 +1,8 @@
 import "./headers.js";
 import { processMiddlewareHeaders } from "./request-pipeline.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
-import { NEVER_CACHE_CONTROL, STATIC_CACHE_CONTROL, applyCdnResponseHeaders, buildCachedRevalidateCacheControl } from "./cache-control.js";
+import { applyCdnResponseHeaders } from "./cache-control.js";
+import { buildAppRouteMissIsrCacheControl, decideIsr } from "./isr-decision.js";
 import { mergeMiddlewareResponseHeaders } from "./middleware-response-headers.js";
 import { getSetCookieName } from "./cookie-utils.js";
 //#region src/server/app-route-handler-response.ts
@@ -11,11 +12,6 @@ function hasMiddlewareHeader(headers) {
 	for (const key of headers.keys()) if (key.startsWith("x-middleware-")) return true;
 	return false;
 }
-function buildRouteHandlerCacheControl(cacheState, revalidateSeconds, expireSeconds) {
-	if (revalidateSeconds === 0) return NEVER_CACHE_CONTROL;
-	if (revalidateSeconds === Infinity) return STATIC_CACHE_CONTROL;
-	return buildCachedRevalidateCacheControl(cacheState, revalidateSeconds, expireSeconds);
-}
 function applyRouteHandlerMiddlewareContext(response, middlewareContext) {
 	if (!middlewareContext.headers && middlewareContext.status == null) return response;
 	const responseHeaders = new Headers(response.headers);
@@ -35,9 +31,14 @@ function buildRouteHandlerCachedResponse(cachedValue, options) {
 	for (const [key, value] of Object.entries(cachedValue.headers)) if (Array.isArray(value)) for (const entry of value) headers.append(key, entry);
 	else headers.set(key, value);
 	setCacheStateHeaders(headers, options.cacheState);
-	const revalidateSeconds = options.cacheControl?.revalidate ?? options.revalidateSeconds;
-	const expireSeconds = options.cacheControl === void 0 ? void 0 : options.cacheControl.expire ?? options.expireSeconds;
-	applyCdnResponseHeaders(headers, { cacheControl: buildRouteHandlerCacheControl(options.cacheState, revalidateSeconds, expireSeconds) });
+	const { cacheControl } = decideIsr({
+		cacheState: options.cacheState,
+		kind: "app-route",
+		revalidateSeconds: options.revalidateSeconds,
+		expireSeconds: options.expireSeconds,
+		cacheControlMeta: options.cacheControl
+	});
+	applyCdnResponseHeaders(headers, { cacheControl });
 	return new Response(options.isHead ? null : cachedValue.body, {
 		status: cachedValue.status,
 		headers
@@ -45,7 +46,7 @@ function buildRouteHandlerCachedResponse(cachedValue, options) {
 }
 function applyRouteHandlerRevalidateHeader(response, revalidateSeconds, expireSeconds, tags) {
 	applyCdnResponseHeaders(response.headers, {
-		cacheControl: buildRouteHandlerCacheControl("HIT", revalidateSeconds, expireSeconds),
+		cacheControl: buildAppRouteMissIsrCacheControl(revalidateSeconds, expireSeconds),
 		tags
 	});
 }

package/dist/server/app-route-handler-runtime.d.ts

@@ -24,6 +24,7 @@ type AppRouteRequestMode = "auto" | "force-static" | "error";
 type TrackedAppRouteRequestOptions = {
   basePath?: string;
   i18n?: NextI18nConfig | null;
+  trailingSlash?: boolean;
   middlewareHeaders?: Headers | null;
   onDynamicAccess?: (access: AppRouteDynamicRequestAccess) => void;
   requestMode?: AppRouteRequestMode;

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

@@ -1,3 +1,4 @@
+import { addBasePathToPathname } from "../utils/base-path.js";
 import { buildRequestHeadersFromMiddlewareResponse } from "./middleware-request-headers.js";
 import { NextRequest, RequestCookies, sealRequestCookies, sealRequestHeaders } from "../shims/server.js";
 //#region src/server/app-route-handler-runtime.ts
@@ -43,10 +44,11 @@ function bindMethodIfNeeded(value, target) {
 	return typeof value === "function" ? value.bind(target) : value;
 }
 function buildNextConfig(options) {
-	if (!options.basePath && !options.i18n) return null;
+	if (!options.basePath && !options.i18n && !options.trailingSlash) return null;
 	return {
 		basePath: options.basePath,
-		i18n: options.i18n ?? void 0
+		i18n: options.i18n ?? void 0,
+		trailingSlash: options.trailingSlash
 	};
 }
 function rebuildRequestWithHeaders(input, headers) {
@@ -155,7 +157,17 @@ function createTrackedAppRouteRequest(request, options = {}) {
 			}
 		} });
 	};
-	const wrapRequest = (input) => {
+	const wrapRequest = (rawInput) => {
+		let input = rawInput;
+		if (options.basePath) {
+			const inputUrl = new URL(rawInput.url);
+			const prefixedPathname = addBasePathToPathname(inputUrl.pathname, options.basePath);
+			if (prefixedPathname !== inputUrl.pathname) {
+				inputUrl.pathname = prefixedPathname;
+				const bodySource = rawInput.body && !rawInput.bodyUsed ? rawInput.clone() : rawInput;
+				input = new Request(inputUrl, bodySource);
+			}
+		}
 		const requestHeaders = options.middlewareHeaders ? buildRequestHeadersFromMiddlewareResponse(input.headers, options.middlewareHeaders) : null;
 		const requestWithOverrides = requestHeaders ? rebuildRequestWithHeaders(input, requestHeaders) : input;
 		const nextRequest = requestWithOverrides instanceof NextRequest ? requestWithOverrides : new NextRequest(requestWithOverrides, { nextConfig: nextConfig ?? void 0 });

package/dist/server/app-rsc-handler.d.ts

@@ -30,6 +30,7 @@ type AppRscRouteMatch<TRoute> = {
 type DispatchMatchedPageOptions<TRoute> = {
   clientReuseManifest: ClientReuseManifestParseResult;
   cleanPathname: string;
+  displayPathname: string;
   formState: ReactFormState | null;
   actionError?: unknown;
   actionFailed?: boolean;