vinext 1.0.0-beta.9 → 1.0.0

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

@@ -1,21 +1,23 @@
+import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
+import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
 import { runWithExecutionContext } from "../shims/request-context.js";
 import "./server-globals.js";
-import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_REVALIDATE_HOST_HEADER } from "../utils/protocol-headers.js";
+import "./app-rsc-vary.js";
 import { VINEXT_CACHEABILITY_PROBE_QUERY_PARAM } from "./headers.js";
 import { badRequestResponse, notFoundResponse, notFoundStaticAssetResponse } from "./http-error-responses.js";
 import { isOpenRedirectShaped } from "./open-redirect.js";
 import { cloneRequestWithHeaders, filterInternalHeaders } from "./request-pipeline.js";
 import { getCdnCacheAdapter } from "../shims/cdn-cache.js";
 import { applyCdnResponseIdentityHeaders, validateCdnRequest } from "./cache-control.js";
-import { assetPrefixPathname, isNextStaticPath } from "../utils/asset-prefix.js";
 import { getImageOptimizer, handleConfiguredImageOptimization, isImageOptimizationPath } from "./image-optimization.js";
+import { traceFrameworkRequest } from "./request-tracing.js";
 import { createStaticAssetRequest, finalizeMissingStaticAssetResponse, resolveStaticAssetSignal } from "./worker-utils.js";
 import { readTrustedPrerenderRouteParams, serializePrerenderRouteParamsHeader } from "./prerender-route-params.js";
 import { createWorkerRevalidationContext } from "./worker-revalidation-context.js";
 import { createWorkerPrerenderDiscoveryContext, createWorkerPrerenderReadinessResponse } from "./worker-prerender-discovery.js";
-import rscHandler, { __assetPrefix, __basePath, __cacheabilityManifest, __imageAllowedWidths, __imageConfig, __prerenderSecret } from "virtual:vinext-rsc-entry";
-import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
 import { registerConfiguredImageOptimizer } from "virtual:vinext-image-adapters";
+import { registerConfiguredCacheAdapters } from "virtual:vinext-cache-adapters";
+import rscHandler, { __assetPrefix, __basePath, __cacheabilityManifest, __ensureHybridPagesApplication, __ensureInstrumentation, __imageAllowedWidths, __imageConfig, __prerenderSecret } from "virtual:vinext-rsc-entry";
 //#region src/server/app-router-entry.ts
 const __workerBasePath = typeof __basePath === "string" ? __basePath : "";
 const __workerAssetPathPrefix = assetPrefixPathname(typeof __assetPrefix === "string" ? __assetPrefix : "");
@@ -24,16 +26,34 @@ function isPotentialCompletedAdmissionRequest(request) {
 	if (request.headers.has("next-action") || request.headers.has("x-rsc-action")) return false;
 	return true;
 }
-var app_router_entry_default = { async fetch(request, env, ctx) {
-	return applyCdnResponseIdentityHeaders(await handleRequest(request, env, ctx), request);
-} };
+var app_router_entry_default = {
+	__ensureInstrumentation,
+	async fetch(request, env, ctx) {
+		const handleFetch = async () => {
+			await __ensureInstrumentation();
+			const url = new URL(request.url);
+			return traceFrameworkRequest({
+				callback: async () => applyCdnResponseIdentityHeaders(await handleRequest(request, env, ctx), request),
+				getStatus: (response) => response?.status,
+				headers: request.headers,
+				isRsc: url.pathname.endsWith(".rsc") || request.headers.get("RSC") === "1",
+				method: request.method,
+				target: url.pathname + url.search
+			});
+		};
+		return ctx ? runWithExecutionContext(ctx, handleFetch) : handleFetch();
+	}
+};
 async function handleRequest(request, env, platformCtx) {
 	const requestCtx = platformCtx?.trustedRevalidateOrigin ? platformCtx : createWorkerRevalidationContext(platformCtx, (internalRequest, internalCtx) => handleRequest(internalRequest, env, internalCtx));
 	registerConfiguredCacheAdapters(env);
 	const cdnCacheAdapter = getCdnCacheAdapter();
 	let ctx = createWorkerPrerenderDiscoveryContext(requestCtx, request, __prerenderSecret);
 	const readinessResponse = createWorkerPrerenderReadinessResponse(ctx, request);
-	if (readinessResponse) return await validateCdnRequest(request) ?? readinessResponse;
+	if (readinessResponse) {
+		if (readinessResponse.status === 204) await __ensureHybridPagesApplication();
+		return await validateCdnRequest(request) ?? readinessResponse;
+	}
 	let finalizeCacheabilityResponse;
 	if (request.headers.has("X-Vinext-Cacheability-Probe")) {
 		const cacheability = await import("./cacheability-request.js");

package/dist/server/app-rsc-cache-busting.d.ts

@@ -1,4 +1,4 @@
-import { VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER } from "./headers.js";
+import { VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
 import { AppRscRenderMode } from "./app-rsc-render-mode.js";
 import { AppRscStateFingerprintInput } from "./app-rsc-state-fingerprint.js";
 //#region src/server/app-rsc-cache-busting.d.ts
@@ -8,10 +8,10 @@ import { AppRscStateFingerprintInput } from "./app-rsc-state-fingerprint.js";
  * proxies; stripping them changes the server hash and turns stale URLs into
  * repeated canonicalization redirects.
  */
-declare const VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM = "_rsc";
-declare const VINEXT_RSC_BUILD_ID_HEADER = "X-Vinext-RSC-Build-Id";
-declare const VINEXT_RSC_COMPATIBILITY_ID_HEADER = "X-Vinext-RSC-Compatibility-Id";
-declare const VINEXT_RSC_CONTENT_TYPE = "text/x-component";
+export declare const VINEXT_RSC_CACHE_BUSTING_SEARCH_PARAM = "_rsc";
+export declare const VINEXT_RSC_BUILD_ID_HEADER = "X-Vinext-RSC-Build-Id";
+export declare const VINEXT_RSC_COMPATIBILITY_ID_HEADER = "X-Vinext-RSC-Compatibility-Id";
+export declare const VINEXT_RSC_CONTENT_TYPE = "text/x-component";
 type CreateRscRequestHeadersOptions = {
   clientReuseManifestHeader?: string | null;
   interceptionContext?: string | null;
@@ -32,18 +32,18 @@ type ResolveInvalidRscCacheBustingRequestOptions = {
   isRscRequest: boolean;
   request: Request;
 };
-declare function getVinextRscCompatibilityId(): string | null;
-declare function applyRscCompatibilityIdHeader(headers: Headers, compatibilityId?: string | null | undefined, buildId?: string | null | undefined): void;
-declare function applyRscDeploymentIdHeader(headers: Headers): void;
-declare function isRscCompatibilityIdCompatible(responseCompatibilityId: string | null | undefined, clientCompatibilityId?: string | null | undefined): boolean;
+export declare function getVinextRscCompatibilityId(): string | null;
+export declare function applyRscCompatibilityIdHeader(headers: Headers, compatibilityId?: string | null | undefined, buildId?: string | null | undefined): void;
+export declare function applyRscDeploymentIdHeader(headers: Headers): void;
+export declare function isRscCompatibilityIdCompatible(responseCompatibilityId: string | null | undefined, clientCompatibilityId?: string | null | undefined): boolean;
 type RscCompatibilityNavigationDecision = {
   kind: "compatible";
 } | {
   hardNavigationTarget: string;
   kind: "hard-navigate";
 };
-declare function resolveHardNavigationTargetFromRscResponse(responseUrl: string | null | undefined, currentHref: string, origin: string): string;
-declare function resolveRscCompatibilityNavigationDecision(options: {
+export declare function resolveHardNavigationTargetFromRscResponse(responseUrl: string | null | undefined, currentHref: string, origin: string): string;
+export declare function resolveRscCompatibilityNavigationDecision(options: {
   clientCompatibilityId?: string | null;
   currentHref: string;
   origin: string;
@@ -57,36 +57,43 @@ declare function resolveRscCompatibilityNavigationDecision(options: {
  * built on this helper and the stripper can never disagree on which pairs
  * count as `_rsc`, including encoded-key edge cases like `%5Frsc`.
  */
-declare function hasRscCacheBustingSearchParam(url: URL): boolean;
-declare function computeRscCacheBustingSearchParam(headers: Headers): Promise<string>;
-declare function setRscCacheBustingSearchParam(url: URL, hash: string): void;
-declare function stripRscCacheBustingSearchParam(url: URL): void;
+export declare function hasRscCacheBustingSearchParam(url: URL): boolean;
+export declare function computeRscCacheBustingSearchParam(headers: Headers): Promise<string>;
+export declare function setRscCacheBustingSearchParam(url: URL, hash: string): void;
+export declare function stripRscCacheBustingSearchParam(url: URL): void;
+/**
+ * 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.
+ */
+export declare function keepOnlyValidatedRscCacheBustingSearchParam(url: URL, isRscRequest: boolean): void;
 /**
  * Remove a trailing `.rsc` suffix from a pathname. Returns the pathname
  * unchanged when the suffix is absent.
  */
-declare function stripRscSuffix(pathname: string): string;
-declare function createCanonicalRscRequestHeaders(deploymentId?: string | null | undefined): Headers;
+export declare function stripRscSuffix(pathname: string): string;
+export declare function createCanonicalRscRequestHeaders(deploymentId?: string | null | undefined): Headers;
 /** Headers for the deterministic loading-boundary prefetch representation. */
-declare function createCanonicalLoadingShellRscRequestHeaders(deploymentId?: string | null | undefined): Headers;
-declare function createRscRequestHeaders(options?: CreateRscRequestHeadersOptions): Headers;
+export declare function createCanonicalLoadingShellRscRequestHeaders(deploymentId?: string | null | undefined): Headers;
+export declare function createRscRequestHeaders(options?: CreateRscRequestHeadersOptions): 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.
  */
-declare function canonicalizePrewarmableRscRequestHeaders(headers: Headers): boolean;
+export declare function canonicalizePrewarmableRscRequestHeaders(headers: Headers): boolean;
 /**
  * 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.
  */
-declare function canonicalizeLoadingShellRscRequestHeaders(headers: Headers): boolean;
-declare function createRscRequestUrl(href: string, headers: Headers): Promise<string>;
+export declare function canonicalizeLoadingShellRscRequestHeaders(headers: Headers): boolean;
+export declare function createRscRequestUrl(href: string, headers: Headers): Promise<string>;
 /** Build the definitive full-route RSC URL shared by prefetch and navigation. */
-declare function createCanonicalRscRequestUrl(href: string): string;
-declare function createServerActionRequestUrl(href: string): string;
-declare function createRscRedirectLocation(location: string, request: Request): Promise<string>;
-declare function resolveInvalidRscCacheBustingRequest(options: ResolveInvalidRscCacheBustingRequestOptions): Promise<Response | null>;
+export declare function createCanonicalRscRequestUrl(href: string): string;
+export declare function createServerActionRequestUrl(href: string): string;
+export declare function createRscRedirectLocation(location: string, request: Request): Promise<string>;
+export declare function resolveInvalidRscCacheBustingRequest(options: ResolveInvalidRscCacheBustingRequestOptions): Promise<Response | null>;
 //#endregion
-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, resolveHardNavigationTargetFromRscResponse, resolveInvalidRscCacheBustingRequest, resolveRscCompatibilityNavigationDecision, setRscCacheBustingSearchParam, stripRscCacheBustingSearchParam, stripRscSuffix };
+export { VINEXT_RSC_RENDER_MODE_HEADER, VINEXT_RSC_VARY_HEADER };

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

@@ -1,4 +1,5 @@
-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, VINEXT_RSC_VARY_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 { APP_RSC_RENDER_MODE_PREFETCH_LOADING_SHELL, parseAppRscRenderMode } from "./app-rsc-render-mode.js";
 import { applyDeploymentIdHeader, getDeploymentId } from "../utils/deployment-id.js";
@@ -136,6 +137,17 @@ 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.
 */
@@ -297,4 +309,4 @@ async function resolveInvalidRscCacheBustingRequest(options) {
 	});
 }
 //#endregion
-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, 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[];
@@ -44,6 +50,7 @@ type AppRscRouteMatch<TRoute> = {
 };
 type DispatchMatchedPageOptions<TRoute> = {
   bypassInterceptionContextCache: boolean;
+  cachePathname: string;
   clientReuseManifest: ClientReuseManifestParseResult;
   cleanPathname: string;
   displayPathname: string;
@@ -80,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;
   /**
@@ -154,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;
@@ -168,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[];
@@ -196,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>;
@@ -221,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