vinext 1.0.0-beta.9 → 1.0.1

package/dist/server/app-route-request-built-ins.d.ts

@@ -1,5 +1,5 @@
 //#region src/server/app-route-request-built-ins.d.ts
-type BuiltInRequestProperty = {
+export type BuiltInRequestProperty = {
   descriptor: PropertyDescriptor;
   instanceOnly: boolean;
   key: PropertyKey;
@@ -11,6 +11,5 @@ type BuiltInRequestProperty = {
  * The production RSC entry imports this module ahead of userland; the global
  * symbol also preserves that first snapshot for the lazy dispatch chunk.
  */
-declare const BUILT_IN_REQUEST_PROPERTIES: readonly BuiltInRequestProperty[];
-//#endregion
-export { BUILT_IN_REQUEST_PROPERTIES, BuiltInRequestProperty };
+export declare const BUILT_IN_REQUEST_PROPERTIES: readonly BuiltInRequestProperty[];
+//#endregion

package/dist/server/app-route-tree-prefetch.d.ts

@@ -15,14 +15,14 @@ type AppRouteTreePrefetchSlot = {
   page?: unknown;
   routeSegments?: readonly string[] | null;
 };
-type AppRouteTreePrefetchRoute = {
+export type AppRouteTreePrefetchRoute = {
   layoutTreePositions?: readonly number[];
   layouts?: readonly unknown[];
   page?: unknown;
   routeSegments: readonly string[];
   slots?: Readonly<Record<string, AppRouteTreePrefetchSlot>> | null;
 };
-type TreePrefetch = {
+export type TreePrefetch = {
   name: string;
   param: TreePrefetchParam | null;
   prefetchHints: number;
@@ -33,11 +33,10 @@ type RouteTreePrefetchResponseOptions = {
   deploymentId?: string;
   prefetchInlining?: PrefetchInliningConfig;
 };
-type PrefetchInliningConfig = false | {
+export type PrefetchInliningConfig = false | {
   maxBundleSize: number;
   maxSize: number;
 };
-declare function isRouteTreePrefetchRequest(request: Request): boolean;
-declare function createRouteTreePrefetchResponse(route: AppRouteTreePrefetchRoute, options?: RouteTreePrefetchResponseOptions): Promise<Response>;
-//#endregion
-export { AppRouteTreePrefetchRoute, PrefetchInliningConfig, TreePrefetch, createRouteTreePrefetchResponse, isRouteTreePrefetchRequest };
+export declare function isRouteTreePrefetchRequest(request: Request): boolean;
+export declare function createRouteTreePrefetchResponse(route: AppRouteTreePrefetchRoute, options?: RouteTreePrefetchResponseOptions): Promise<Response>;
+//#endregion

package/dist/server/app-route-tree-prefetch.js

@@ -1,4 +1,5 @@
-import { NEXTJS_DEPLOYMENT_ID_HEADER, VINEXT_RSC_VARY_HEADER } from "./headers.js";
+import { VINEXT_RSC_VARY_HEADER } from "./app-rsc-vary.js";
+import { NEXTJS_DEPLOYMENT_ID_HEADER } from "./headers.js";
 import { getDeploymentId } from "../utils/deployment-id.js";
 import { VINEXT_RSC_CONTENT_TYPE, applyRscCompatibilityIdHeader } from "./app-rsc-cache-busting.js";
 //#region src/server/app-route-tree-prefetch.ts

package/dist/server/app-router-entry.d.ts

@@ -1,4 +1,6 @@
+import { VinextRequestStageContext } from "./multi-stage.js";
 import { ExecutionContextLike } from "../shims/request-context.js";
+import { __ensureInstrumentation } from "virtual:vinext-rsc-entry";
 //#region src/server/app-router-entry.d.ts
 type WorkerAssetEnv = {
   ASSETS?: {
@@ -6,7 +8,8 @@ type WorkerAssetEnv = {
   };
 };
 declare const _default: {
-  fetch(request: Request, env?: WorkerAssetEnv, ctx?: ExecutionContextLike): Promise<Response>;
+  __ensureInstrumentation: typeof __ensureInstrumentation;
+  fetch(request: Request, env?: WorkerAssetEnv, ctx?: ExecutionContextLike & VinextRequestStageContext): Promise<Response>;
 };
 //#endregion
 export { _default as default };

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 { createStaticAssetRequest, finalizeMissingStaticAssetResponse, resolveStaticAssetSignal } from "./worker-utils.js";
+import { traceFrameworkRequest } from "./request-tracing.js";
+import { createStaticAssetRequest, 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,35 @@ 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();
+	const assets = platformCtx?.assets ?? cdnCacheAdapter.assets ?? env?.ASSETS;
 	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");
@@ -61,10 +82,7 @@ async function handleRequest(request, env, platformCtx) {
 	const cdnValidationResponse = await validateCdnRequest(request);
 	if (cdnValidationResponse) return cdnValidationResponse;
 	const url = new URL(request.url);
-	if (isImageOptimizationPath(url.pathname) && env?.ASSETS && getImageOptimizer()) {
-		const assetFetcher = env.ASSETS;
-		return handleConfiguredImageOptimization(request, (assetPath) => Promise.resolve(assetFetcher.fetch(new Request(new URL(assetPath, request.url)))), __imageAllowedWidths, __imageConfig);
-	}
+	if (isImageOptimizationPath(url.pathname) && assets && getImageOptimizer()) return handleConfiguredImageOptimization(request, (assetPath) => Promise.resolve(assets.fetch(new Request(new URL(assetPath, request.url)))), __imageAllowedWidths, __imageConfig);
 	if (isOpenRedirectShaped(url.pathname)) return notFoundResponse();
 	try {
 		decodeURIComponent(url.pathname);
@@ -85,12 +103,10 @@ async function handleRequest(request, env, platformCtx) {
 	const result = await (ctx ? runWithExecutionContext(ctx, handleFn) : handleFn());
 	if (result instanceof Response) {
 		let response = result;
-		if (env?.ASSETS) {
-			const assetFetcher = env.ASSETS;
-			const assetResponse = await resolveStaticAssetSignal(response, { fetchAsset: (path) => Promise.resolve(assetFetcher.fetch(createStaticAssetRequest(path, request))) });
+		if (assets) {
+			const assetResponse = await resolveStaticAssetSignal(response, { fetchAsset: (path) => Promise.resolve(assets.fetch(createStaticAssetRequest(path, request))) });
 			if (assetResponse) response = assetResponse;
 		}
-		response = finalizeMissingStaticAssetResponse(response, missingBuildAsset);
 		return finalizeCacheabilityResponse ? finalizeCacheabilityResponse(response, ctx) : response;
 	}
 	if (result === null || result === void 0) {

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,16 +7,19 @@ 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;
 };
 /**
@@ -29,12 +32,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

@@ -1,5 +1,6 @@
 import { isNavigationSignalError } from "../utils/navigation-signal.js";
 import { resolveAppPageSpecialError } from "./app-page-execution.js";
+import { isAppRenderAbortError } from "./app-render-abort-error.js";
 //#region src/server/app-rsc-errors.ts
 const ORIGINAL_SERVER_ERROR = Symbol.for("vinext.originalServerError");
 function hasDigest(error) {
@@ -7,11 +8,6 @@ function hasDigest(error) {
 }
 const BAILOUT_TO_CSR_DIGEST = "BAILOUT_TO_CLIENT_SIDE_RENDERING";
 const DYNAMIC_SERVER_USAGE_DIGEST = "DYNAMIC_SERVER_USAGE";
-function isAbortError(error) {
-	if (!error || typeof error !== "object") return false;
-	const name = Reflect.get(error, "name");
-	return name === "AbortError" || name === "ResponseAborted";
-}
 /**
 * vinext's mirror of Next.js's `getDigestForWellKnownError`: returns the digest
 * string only when the error is a genuine control-flow signal — a redirect,
@@ -55,27 +51,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;