vinext 1.0.0-beta.8 → 1.0.0

package/dist/server/app-rsc-cache-busting.js

@@ -1,6 +1,7 @@
-import { NEXTJS_DEPLOYMENT_ID_HEADER, NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERCEPTION_ID_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_STATE_FINGERPRINT_HEADER } from "./headers.js";
+import { NEXT_ROUTER_PREFETCH_HEADER, NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, NEXT_ROUTER_STATE_TREE_HEADER, NEXT_URL_HEADER, VINEXT_INTERCEPTION_CONTEXT_HEADER, VINEXT_INTERCEPTION_ID_HEADER, VINEXT_MOUNTED_SLOTS_HEADER, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_STATE_FINGERPRINT_HEADER, VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
+import { NEXTJS_DEPLOYMENT_ID_HEADER, VINEXT_CLIENT_REUSE_MANIFEST_HEADER } from "./headers.js";
 import { fnv1a64 } from "../utils/hash.js";
-import { parseAppRscRenderMode } from "./app-rsc-render-mode.js";
+import { APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, parseAppRscRenderMode } from "./app-rsc-render-mode.js";
 import { applyDeploymentIdHeader, getDeploymentId } from "../utils/deployment-id.js";
 import { createAppRscStateFingerprint } from "./app-rsc-state-fingerprint.js";
 //#region src/server/app-rsc-cache-busting.ts
@@ -11,20 +12,9 @@ import { createAppRscStateFingerprint } from "./app-rsc-state-fingerprint.js";
 * repeated canonicalization redirects.
 */
 const VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM = "_rsc";
+const VINEXT_RSC_BUILD_ID_HEADER = "X-Vinext-RSC-Build-Id";
 const VINEXT_RSC_COMPATIBILITY_ID_HEADER = "X-Vinext-RSC-Compatibility-Id";
 const VINEXT_RSC_CONTENT_TYPE = "text/x-component";
-const VINEXT_RSC_VARY_HEADER = [
-	"RSC",
-	NEXT_ROUTER_STATE_TREE_HEADER,
-	NEXT_ROUTER_PREFETCH_HEADER,
-	NEXT_ROUTER_SEGMENT_PREFETCH_HEADER,
-	NEXT_URL_HEADER,
-	VINEXT_INTERCEPTION_CONTEXT_HEADER,
-	VINEXT_INTERCEPTION_ID_HEADER,
-	VINEXT_MOUNTED_SLOTS_HEADER,
-	VINEXT_RSC_RENDER_MODE_HEADER,
-	VINEXT_RSC_STATE_FINGERPRINT_HEADER
-].join(", ");
 const CACHE_BUSTING_DIGEST_BYTES = 12;
 const textEncoder = new TextEncoder();
 function encodeBase64Url(bytes) {
@@ -41,10 +31,16 @@ function normalizeCompatibilityId(value) {
 function getVinextRscCompatibilityId() {
 	return normalizeCompatibilityId(process.env.__VINEXT_RSC_COMPATIBILITY_ID);
 }
-function applyRscCompatibilityIdHeader(headers, compatibilityId = getVinextRscCompatibilityId()) {
+function getVinextRscBuildId() {
+	return normalizeCompatibilityId(process.env.__VINEXT_RSC_BUILD_IDENTITY);
+}
+function applyRscCompatibilityIdHeader(headers, compatibilityId = getVinextRscCompatibilityId(), buildId = getVinextRscBuildId()) {
 	const normalized = normalizeCompatibilityId(compatibilityId);
 	if (normalized) headers.set(VINEXT_RSC_COMPATIBILITY_ID_HEADER, normalized);
 	else headers.delete(VINEXT_RSC_COMPATIBILITY_ID_HEADER);
+	const normalizedBuildId = normalizeCompatibilityId(buildId);
+	if (normalizedBuildId) headers.set(VINEXT_RSC_BUILD_ID_HEADER, normalizedBuildId);
+	else headers.delete(VINEXT_RSC_BUILD_ID_HEADER);
 }
 function applyRscDeploymentIdHeader(headers) {
 	const deploymentId = getDeploymentId();
@@ -141,18 +137,41 @@ function stripRscCacheBustingSearchParam(url) {
 	url.search = pairs.length > 0 ? `?${pairs.join("&")}` : "";
 }
 /**
+* Reduce a URL's query to the one `_rsc` value that selects its representation.
+* For RSC requests that is the value `resolveInvalidRscCacheBustingRequest`
+* validated (the first pair), re-serialized; ignored duplicates and encodings
+* are dropped. Other requests keep no `_rsc`, because it selects nothing there.
+*/
+function keepOnlyValidatedRscCacheBustingSearchParam(url, isRscRequest) {
+	const hash = isRscRequest ? url.searchParams.get(VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM) : null;
+	url.search = "";
+	if (hash !== null) setRscCacheBustingSearchParam(url, hash);
+}
+/**
 * Remove a trailing `.rsc` suffix from a pathname. Returns the pathname
 * unchanged when the suffix is absent.
 */
 function stripRscSuffix(pathname) {
 	return pathname.endsWith(".rsc") ? pathname.slice(0, -4) : pathname;
 }
-function createRscRequestHeaders(options = {}) {
+function createCanonicalRscRequestHeaders(deploymentId = getDeploymentId()) {
 	const headers = new Headers({
 		Accept: VINEXT_RSC_CONTENT_TYPE,
 		["RSC"]: "1"
 	});
-	applyDeploymentIdHeader(headers);
+	applyDeploymentIdHeader(headers, deploymentId ?? void 0);
+	return headers;
+}
+/** Headers for the deterministic loading-boundary prefetch representation. */
+function createCanonicalLoadingShellRscRequestHeaders(deploymentId = getDeploymentId()) {
+	const headers = createCanonicalRscRequestHeaders(deploymentId);
+	headers.set(NEXT_ROUTER_PREFETCH_HEADER, "1");
+	headers.set(NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, "1");
+	headers.set(VINEXT_RSC_RENDER_MODE_HEADER, APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL);
+	return headers;
+}
+function createRscRequestHeaders(options = {}) {
+	const headers = createCanonicalRscRequestHeaders(options.deploymentId);
 	if (options.prefetchRouterState) {
 		if (options.includePrefetchHeader !== false) headers.set(NEXT_ROUTER_PREFETCH_HEADER, "1");
 		headers.set(NEXT_ROUTER_STATE_TREE_HEADER, encodeURIComponent(JSON.stringify(options.prefetchRouterState)));
@@ -169,15 +188,58 @@ function createRscRequestHeaders(options = {}) {
 	if (renderMode !== "navigation") headers.set(VINEXT_RSC_RENDER_MODE_HEADER, renderMode);
 	return headers;
 }
+/**
+* Convert a full, non-contextual navigation request to the definitive ISR RSC
+* variant. Partial/intercepted/mounted-slot payloads remain contextual because
+* their bytes can legitimately differ from the destination's full route.
+*/
+function canonicalizePrewarmableRscRequestHeaders(headers) {
+	if (headers.has("X-Vinext-Rsc-Render-Mode") || headers.has("X-Vinext-Interception-Context") || headers.has("X-Vinext-Interception-Id") || headers.has("X-Vinext-Mounted-Slots")) return false;
+	headers.delete(NEXT_ROUTER_PREFETCH_HEADER);
+	headers.delete(NEXT_ROUTER_SEGMENT_PREFETCH_HEADER);
+	headers.delete(NEXT_ROUTER_STATE_TREE_HEADER);
+	headers.delete(NEXT_URL_HEADER);
+	headers.delete(VINEXT_RSC_STATE_FINGERPRINT_HEADER);
+	headers.delete(VINEXT_CLIENT_REUSE_MANIFEST_HEADER);
+	return true;
+}
+/**
+* Convert an ordinary loading-boundary prefetch to the shared loading-shell
+* variant. The payload is selected by the three retained mode headers; visible
+* router state is transport context and must not fragment the shared response.
+*/
+function canonicalizeLoadingShellRscRequestHeaders(headers) {
+	if (headers.get("X-Vinext-Rsc-Render-Mode") !== "prefetch-loading-shell" || headers.has("X-Vinext-Interception-Context") || headers.has("X-Vinext-Interception-Id") || headers.has("X-Vinext-Mounted-Slots")) return false;
+	headers.set(NEXT_ROUTER_PREFETCH_HEADER, "1");
+	headers.set(NEXT_ROUTER_SEGMENT_PREFETCH_HEADER, "1");
+	headers.delete(NEXT_ROUTER_STATE_TREE_HEADER);
+	headers.delete(NEXT_URL_HEADER);
+	headers.delete(VINEXT_RSC_STATE_FINGERPRINT_HEADER);
+	headers.delete(VINEXT_CLIENT_REUSE_MANIFEST_HEADER);
+	return true;
+}
 function toRscRequestPath(href) {
 	const hashIndex = href.indexOf("#");
 	return hashIndex === -1 ? href : href.slice(0, hashIndex);
 }
 async function createRscRequestUrl(href, headers) {
 	const url = new URL(toRscRequestPath(href), "http://vinext.local");
+	if (typeof window !== "undefined" && process.env.NODE_ENV === "production" && process.env.__NEXT_CONFIG_OUTPUT === "export") {
+		const basePath = process.env.__NEXT_ROUTER_BASEPATH ?? "";
+		const isBasePathRoot = basePath !== "" && url.pathname === basePath;
+		if (url.pathname.endsWith("/")) url.pathname += "index.txt";
+		else url.pathname += isBasePathRoot ? "/index.txt" : ".txt";
+		return `${url.pathname}${url.search}`;
+	}
 	setRscCacheBustingSearchParam(url, await computeRscCacheBustingSearchParam(headers));
 	return `${url.pathname}${url.search}`;
 }
+/** Build the definitive full-route RSC URL shared by prefetch and navigation. */
+function createCanonicalRscRequestUrl(href) {
+	const url = new URL(toRscRequestPath(href), "http://vinext.local");
+	setRscCacheBustingSearchParam(url, "");
+	return `${url.pathname}${url.search}`;
+}
 function createServerActionRequestUrl(href) {
 	const hashIndex = href.indexOf("#");
 	const beforeHash = hashIndex === -1 ? href : href.slice(0, hashIndex);
@@ -247,4 +309,4 @@ async function resolveInvalidRscCacheBustingRequest(options) {
 	});
 }
 //#endregion
-export { VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, computeRscCacheBustingSearchParam, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };
+export { VINEXT_RSC_BUILD_ID_HEADER, VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM, VINEXT_RSC_COMPATIBILITY_ID_HEADER, VINEXT_RSC_CONTENT_TYPE, VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER, applyRscCompatibilityIdHeader, applyRscDeploymentIdHeader, canonicalizeLoadingShellRscRequestHeaders, canonicalizePrewarmableRscRequestHeaders, computeRscCacheBustingSearchParam, createCanonicalLoadingShellRscRequestHeaders, createCanonicalRscRequestHeaders, createCanonicalRscRequestUrl, createRscRedirectLocation, createRscRequestHeaders, createRscRequestUrl, createServerActionRequestUrl, getVinextRscCompatibilityId, hasRscCacheBustingSearchParam, isRscCompatibilityIdCompatible, keepOnlyValidatedRscCacheBustingSearchParam, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };

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

@@ -0,0 +1,9 @@
+import { VinextResponseStageDispatchOptions } from "./multi-stage.js";
+import { AppWorkerResponseStageProps } from "./app-worker-stages.js";
+import { AppRscHandlerRoute, AppRscRequestHandler, CreateAppRscHandlerOptions } from "./app-rsc-handler.js";
+//#region src/server/app-rsc-combined-handler.d.ts
+export type AppRscHandler = AppRscRequestHandler & {
+  handleResponseStage(request: Request, ctx: unknown, props: AppWorkerResponseStageProps, options?: VinextResponseStageDispatchOptions): Promise<Response>;
+};
+export declare function createAppRscHandler<TRoute extends AppRscHandlerRoute>(options: CreateAppRscHandlerOptions<TRoute>): AppRscHandler;
+//#endregion

package/dist/server/app-rsc-combined-handler.js

@@ -0,0 +1,11 @@
+import { createAppRscRequestHandler } from "./app-rsc-handler.js";
+//#region src/server/app-rsc-combined-handler.ts
+/** Combined request/response handler used by default single-stage App entries. */
+function createAppRscHandler(options) {
+	const appRscHandler = createAppRscRequestHandler(options);
+	return Object.assign(appRscHandler, { handleResponseStage(request, ctx, props, stageOptions) {
+		return import("./app-rsc-response-stage.js").then(({ renderAppWorkerResponseStage }) => renderAppWorkerResponseStage(options, request, ctx, props, stageOptions));
+	} });
+}
+//#endregion
+export { createAppRscHandler };

package/dist/server/app-rsc-embedded-chunks.d.ts

@@ -1,8 +1,7 @@
 //#region src/server/app-rsc-embedded-chunks.d.ts
-declare const RSC_EMBEDDED_BINARY_CHUNK = 3;
-type RscEmbeddedChunk = string | [typeof RSC_EMBEDDED_BINARY_CHUNK, string];
-declare function bytesToBase64(bytes: Uint8Array): string;
-declare function decodeRscEmbeddedChunk(chunk: RscEmbeddedChunk): Uint8Array;
-declare function concatUint8Arrays(chunks: readonly Uint8Array[]): Uint8Array<ArrayBuffer>;
-//#endregion
-export { RSC_EMBEDDED_BINARY_CHUNK, RscEmbeddedChunk, bytesToBase64, concatUint8Arrays, decodeRscEmbeddedChunk };
+export declare const RSC_EMBEDDED_BINARY_CHUNK = 3;
+export type RscEmbeddedChunk = string | [typeof RSC_EMBEDDED_BINARY_CHUNK, string];
+export declare function bytesToBase64(bytes: Uint8Array): string;
+export declare function decodeRscEmbeddedChunk(chunk: RscEmbeddedChunk): Uint8Array;
+export declare function concatUint8Arrays(chunks: readonly Uint8Array[]): Uint8Array<ArrayBuffer>;
+//#endregion

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

@@ -1,13 +1,20 @@
 //#region src/server/app-rsc-error-handler.d.ts
-type ReportRequestError = (error: Error, requestInfo: {
+type ReportRequestError = (error: unknown, requestInfo: {
   path: string;
   method: string;
   headers: Record<string, string>;
 }, errorContext: {
   routerKind: "App Router";
   routePath: string;
-  routeType: "render";
-}) => void;
+  routeType: "render" | "action";
+  renderSource?: "react-server-components" | "react-server-components-payload" | "server-rendering";
+  revalidateReason: "on-demand" | "stale" | undefined;
+}) => void | Promise<void>;
+export type AppRenderErrorContextOverrides = {
+  renderSource?: "react-server-components" | "react-server-components-payload" | "server-rendering";
+  revalidateReason?: "on-demand" | "stale";
+  routeType?: "render" | "action";
+};
 /**
  * Build a per-request RSC error handler that extracts request metadata from
  * the incoming Web `Request`, wires it into a `createRscOnErrorHandler` call,
@@ -15,6 +22,5 @@ type ReportRequestError = (error: Error, requestInfo: {
  *
  * Pure factory: takes all deps explicitly — no closure over module-level state.
  */
-declare function createAppRscOnErrorHandler(reportRequestError: ReportRequestError, request: Request, pathname: string, routePath: string): (error: unknown) => string | undefined;
-//#endregion
-export { createAppRscOnErrorHandler };
+export declare function createAppRscOnErrorHandler(reportRequestError: ReportRequestError, request: Request, pathname: string, routePath: string, overrides?: AppRenderErrorContextOverrides): (error: unknown) => string | undefined;
+//#endregion

package/dist/server/app-rsc-error-handler.js

@@ -1,3 +1,6 @@
+import "../utils/protocol-headers.js";
+import "./app-rsc-vary.js";
+import { isOnDemandRevalidateRequest } from "./revalidation-request.js";
 import { createRscOnErrorHandler } from "./app-rsc-errors.js";
 //#region src/server/app-rsc-error-handler.ts
 /**
@@ -7,20 +10,26 @@ import { createRscOnErrorHandler } from "./app-rsc-errors.js";
 *
 * Pure factory: takes all deps explicitly — no closure over module-level state.
 */
-function createAppRscOnErrorHandler(reportRequestError, request, pathname, routePath) {
+function createAppRscOnErrorHandler(reportRequestError, request, pathname, routePath, overrides) {
 	const requestHeaders = Object.fromEntries(request.headers.entries());
 	const requestInfo = {
 		path: pathname,
 		method: request.method,
 		headers: requestHeaders
 	};
+	const errorContext = {
+		routerKind: "App Router",
+		routePath: routePath || pathname,
+		routeType: overrides?.routeType ?? "render",
+		renderSource: overrides?.renderSource ?? (request.headers.get("RSC") === "1" || new URL(request.url).pathname.endsWith(".rsc") ? "react-server-components-payload" : "react-server-components"),
+		revalidateReason: isOnDemandRevalidateRequest(request.headers.get("x-prerender-revalidate")) ? "on-demand" : overrides?.revalidateReason
+	};
 	return createRscOnErrorHandler({
-		errorContext: {
-			routerKind: "App Router",
-			routePath: routePath || pathname,
-			routeType: "render"
+		attachDigest: errorContext.renderSource !== "server-rendering",
+		errorContext,
+		reportRequestError(error, info, context) {
+			reportRequestError(error, info, context);
 		},
-		reportRequestError,
 		requestInfo
 	});
 }

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

@@ -7,18 +7,22 @@ type RscRequestInfo = {
 type RscErrorContext = {
   routerKind: "App Router";
   routePath: string;
-  routeType: "render";
+  routeType: "render" | "action";
+  renderSource?: "react-server-components" | "react-server-components-payload" | "server-rendering";
+  revalidateReason: "on-demand" | "stale" | undefined;
 };
-type RscErrorReporter = (error: Error, requestInfo: RscRequestInfo, errorContext: RscErrorContext) => void;
+type RscErrorReporter = (error: unknown, requestInfo: RscRequestInfo, errorContext: RscErrorContext) => void;
 type CreateRscOnErrorHandlerOptions = {
+  attachDigest?: boolean;
   errorContext: RscErrorContext | null;
   nodeEnv?: string;
   reportRequestError: RscErrorReporter;
   requestInfo: RscRequestInfo | null;
 };
-declare function hasDigest(error: unknown): error is {
+export declare function hasDigest(error: unknown): error is {
   digest: unknown;
 };
+export declare function isAppRenderAbortError(error: unknown): boolean;
 /**
  * vinext's mirror of Next.js's `getDigestForWellKnownError`: returns the digest
  * string only when the error is a genuine control-flow signal — a redirect,
@@ -29,12 +33,11 @@ declare function hasDigest(error: unknown): error is {
  * presence of a `digest` field is NOT enough — that conflation swallowed a class
  * of server render errors with no instrumentation/telemetry.
  */
-declare function getDigestForWellKnownError(error: unknown): string | undefined;
+export declare function getDigestForWellKnownError(error: unknown): string | undefined;
 /**
  * djb2 hash matching Next.js's string-hash package for RSC error digests.
  */
-declare function errorDigest(input: string): string;
-declare function sanitizeErrorForClient(error: unknown, nodeEnv?: "development" | "production" | "test"): unknown;
-declare function createRscOnErrorHandler(options: CreateRscOnErrorHandlerOptions): (error: unknown) => string | undefined;
-//#endregion
-export { createRscOnErrorHandler, errorDigest, getDigestForWellKnownError, hasDigest, sanitizeErrorForClient };
+export declare function errorDigest(input: string): string;
+export declare function sanitizeErrorForClient(error: unknown, nodeEnv?: "development" | "production" | "test"): unknown;
+export declare function createRscOnErrorHandler(options: CreateRscOnErrorHandlerOptions): (error: unknown) => string | undefined;
+//#endregion

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

@@ -7,7 +7,7 @@ function hasDigest(error) {
 }
 const BAILOUT_TO_CSR_DIGEST = "BAILOUT_TO_CLIENT_SIDE_RENDERING";
 const DYNAMIC_SERVER_USAGE_DIGEST = "DYNAMIC_SERVER_USAGE";
-function isAbortError(error) {
+function isAppRenderAbortError(error) {
 	if (!error || typeof error !== "object") return false;
 	const name = Reflect.get(error, "name");
 	return name === "AbortError" || name === "ResponseAborted";
@@ -55,27 +55,29 @@ function sanitizeErrorForClient(error, nodeEnv = process.env.NODE_ENV) {
 	return sanitized;
 }
 function createRscOnErrorHandler(options) {
+	let loggedPrerenderErrors;
 	return (error) => {
 		const nodeEnv = options.nodeEnv ?? process.env.NODE_ENV;
-		if (isAbortError(error)) return;
-		const wellKnownDigest = getDigestForWellKnownError(error);
+		const reportableError = error && typeof error === "object" && ORIGINAL_SERVER_ERROR in error ? Reflect.get(error, ORIGINAL_SERVER_ERROR) : error;
+		if (isAppRenderAbortError(error) || isAppRenderAbortError(reportableError)) return;
+		const wellKnownDigest = getDigestForWellKnownError(error) ?? getDigestForWellKnownError(reportableError);
 		if (wellKnownDigest !== void 0) return wellKnownDigest;
 		if (nodeEnv !== "production" && error instanceof Error && error.message.includes("Only plain objects, and a few built-ins, can be passed to Client Components")) {
 			console.error("[vinext] RSC serialization error: a non-plain object was passed from a Server Component to a Client Component.\n\nCommon causes:\n  * Passing a module namespace (import * as X) directly as a prop.\n    Unlike Next.js (webpack), Vite produces real ESM module namespace objects\n    which are not serializable. Fix: pass individual values instead,\n    e.g. <Comp value={module.value} />\n  * Passing a class instance (new Foo()) as a prop.\n    Fix: convert to a plain object, e.g. { id: foo.id, name: foo.name }\n  * Passing a Date, Map, or Set. Use .toISOString(), [...map.entries()], etc.\n  * Passing Object.create(null). Use { ...obj } to restore a prototype.\n\nOriginal error:", error.message);
 			return;
 		}
-		if (options.requestInfo && options.errorContext && error) {
-			const reportableError = typeof error === "object" && ORIGINAL_SERVER_ERROR in error ? Reflect.get(error, ORIGINAL_SERVER_ERROR) : error;
-			options.reportRequestError(reportableError instanceof Error ? reportableError : new Error(getThrownValueMessage(reportableError)), options.requestInfo, options.errorContext);
-		}
-		if (nodeEnv !== "production" && error && !hasDigest(error)) {
-			const loggableError = typeof error === "object" && ORIGINAL_SERVER_ERROR in error ? Reflect.get(error, ORIGINAL_SERVER_ERROR) : error;
-			console.error("[vinext] Server render error:", loggableError);
-		}
+		if (options.requestInfo && options.errorContext && error) options.reportRequestError(reportableError, options.requestInfo, options.errorContext);
+		if (process.env.VINEXT_PRERENDER === "1" && error) {
+			if (!loggedPrerenderErrors?.has(reportableError)) {
+				(loggedPrerenderErrors ??= /* @__PURE__ */ new Set()).add(reportableError);
+				const route = options.requestInfo?.path ?? options.errorContext?.routePath ?? "<unknown>";
+				console.error(`[vinext] Error prerendering route ${JSON.stringify(route)}:`, reportableError);
+			}
+		} else if (nodeEnv !== "production" && error && !hasDigest(error)) console.error("[vinext] Server render error:", reportableError);
 		if (hasDigest(error)) return String(error.digest);
 		if (error) {
 			const digest = errorDigest(getThrownValueMessage(error) + getThrownValueStack(error));
-			if (error instanceof Error) try {
+			if (options.attachDigest !== false && error instanceof Error) try {
 				Object.assign(error, { digest });
 			} catch {}
 			return digest;
@@ -83,4 +85,4 @@ function createRscOnErrorHandler(options) {
 	};
 }
 //#endregion
-export { createRscOnErrorHandler, errorDigest, getDigestForWellKnownError, hasDigest, sanitizeErrorForClient };
+export { createRscOnErrorHandler, errorDigest, getDigestForWellKnownError, hasDigest, isAppRenderAbortError, sanitizeErrorForClient };

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

@@ -1,3 +1,4 @@
+import { VinextCacheabilityProbeMode } from "./multi-stage.js";
 import { NextHeader, NextI18nConfig, NextRedirect, NextRewrite } from "../config/next-config.js";
 import { ImageConfig } from "./image-optimization.js";
 import { AppMiddlewareContext, ApplyAppMiddlewareResult } from "./app-middleware.js";
@@ -6,7 +7,10 @@ import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { RootParams } from "../shims/root-params.js";
 import { AppPagePprFallbackCacheShell } from "./app-ppr-fallback-shell.js";
 import { AppPrerenderRootParamNamesMap, AppPrerenderStaticParamsMap } from "./app-prerender-endpoints.js";
+import { PagesRouteDataKind } from "./pages-route-data-kind.js";
+import { TrustedPrerenderState } from "./prerender-route-params.js";
 import { AppRouteTreePrefetchRoute, PrefetchInliningConfig } from "./app-route-tree-prefetch.js";
+import { DispatchAppWorkerResponseStage, RenderAppWorkerResponseStageLocally } from "./app-worker-stages.js";
 import { ReactFormState } from "react-dom/client";
 //#region src/server/app-rsc-handler.d.ts
 type AppPageParams = Record<string, string | string[]>;
@@ -23,9 +27,11 @@ type RunAppMiddlewareOptions = {
   request: Request;
   validateExternalRewriteRequest: () => Promise<Response | null>;
 };
-type AppRscHandlerRoute = {
+export type AppRscHandlerRoute = {
   __loadPage?: unknown;
   __loadRouteHandler?: unknown;
+  canUseCanonicalLoadingShell?: boolean;
+  forceDynamic?: boolean;
   isDynamic: boolean;
   layouts?: readonly unknown[];
   layoutTreePositions?: readonly number[];
@@ -38,10 +44,13 @@ type AppRscHandlerRoute = {
   slots?: AppRouteTreePrefetchRoute["slots"];
 };
 type AppRscRouteMatch<TRoute> = {
+  interceptionSourceIsConcrete?: boolean;
   params: AppPageParams;
   route: TRoute;
 };
 type DispatchMatchedPageOptions<TRoute> = {
+  bypassInterceptionContextCache: boolean;
+  cachePathname: string;
   clientReuseManifest: ClientReuseManifestParseResult;
   cleanPathname: string;
   displayPathname: string;
@@ -78,6 +87,12 @@ type DispatchMatchedPageOptions<TRoute> = {
   renderMode: AppRscRenderMode;
 };
 type DispatchMatchedRouteHandlerOptions<TRoute> = {
+  /**
+   * Legacy transported cache-bypass bit. Also covers request/cache route-identity
+   * divergence so the response cannot be published under another route's key.
+   */
+  bypassInterceptionContextCache: boolean;
+  cachePathname: string;
   cleanPathname: string;
   middlewareContext: AppRscMiddlewareContext;
   /**
@@ -152,8 +167,10 @@ type RenderPagesFallbackOptions = {
       pattern: string;
     };
   } | null;
+  dispatchPagesResponseStage?: (request: Request, resourceKind: "api" | "page", dataKind?: PagesRouteDataKind, hasRequestAwareDocument?: boolean) => Promise<Response>;
   isDataRequest?: boolean;
   isRscRequest: boolean;
+  initialResponseHeaders?: Headers;
   matchKind?: "dynamic" | "static";
   middlewareContext: AppRscMiddlewareContext;
   pathname?: string;
@@ -166,9 +183,15 @@ type NavigationContextValue = {
   pathname: string;
   searchParams: URLSearchParams;
 };
-type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
+export type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
   basePath: string;
   buildId: string | null;
+  /**
+   * Serialized request-stage projection of the Workers Cache manifest. Shared
+   * App page dispatches whose manifest state is `static-candidate` drop the
+   * user query. Null outside a `vinext deploy` artifact.
+   */
+  cacheabilityRequestProjection?: string | null;
   clearRequestContext: () => void;
   configHeaders: NextHeader[];
   configRedirects: NextRedirect[];
@@ -194,14 +217,17 @@ type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
    * Node server and dev included, not just the Cloudflare worker entry.
    */
   registerCacheAdapters: (env?: Record<string, unknown>) => void;
+  /** Request-only entries dynamically load the response graph for local bypasses. */
+  renderResponseStageLocally?: RenderAppWorkerResponseStageLocally;
   handleProgressiveActionRequest?: (options: HandleProgressiveActionRequestOptions<TRoute>) => Promise<Response | ProgressiveActionFormStateResult | null>;
-  handleMetadataRouteRequest?: (cleanPathname: string) => Promise<Response | null>;
+  handleMetadataRouteRequest?: (cleanPathname: string, routePathname: string) => Promise<Response | null>;
   isMetadataRoutePath?: (cleanPathname: string) => boolean | Promise<boolean>;
   getPrerenderMetadataRoutePaths?: () => Promise<unknown>;
   createPprFallbackShells?: (route: Pick<AppRscHandlerRoute, "params" | "pattern" | "rootParamNames">, params: AppPageParams) => AppPagePprFallbackCacheShell[];
   handleServerActionRequest?: (options: HandleServerActionRequestOptions<TRoute>) => Promise<Response | null>;
   i18nConfig: NextI18nConfig | null;
   imageConfig?: ImageConfig;
+  isMetadataRoute?: (pathname: string) => boolean;
   isDev: boolean;
   hasInterceptionId: (interceptionId: string) => boolean;
   loadPrerenderPagesRoutes?: () => Promise<unknown>;
@@ -219,6 +245,7 @@ type CreateAppRscHandlerOptions<TRoute extends AppRscHandlerRoute> = {
   trailingSlash: boolean;
   validateDevRequestOrigin?: (request: Request) => Response | null;
 };
-declare function createAppRscHandler<TRoute extends AppRscHandlerRoute>(options: CreateAppRscHandlerOptions<TRoute>): (request: Request, ctx: unknown) => Promise<Response>;
-//#endregion
-export { createAppRscHandler };
+export type AppRscRequestHandler = (request: Request, ctx: unknown, allowInternalRscDocumentFallback?: boolean, dispatchResponseStage?: DispatchAppWorkerResponseStage, responseStageProbeMode?: VinextCacheabilityProbeMode | null, trustedPrerenderState?: TrustedPrerenderState | null) => Promise<Response>;
+/** Build the request-only handler without retaining the response renderer graph. */
+export declare function createAppRscRequestHandler<TRoute extends AppRscHandlerRoute>(options: CreateAppRscHandlerOptions<TRoute>): AppRscRequestHandler;
+//#endregion