vinext 1.0.1 → 1.2.0

package/dist/server/proper-error.d.ts

@@ -0,0 +1,4 @@
+//#region src/server/proper-error.d.ts
+/** Turn a thrown value into an Error, as Next.js does before reporting it. */
+export declare function getProperError(error: unknown): Error;
+//#endregion

package/dist/server/proper-error.js

@@ -0,0 +1,31 @@
+//#region src/server/proper-error.ts
+function isPlainObject(value) {
+	if (Object.prototype.toString.call(value) !== "[object Object]") return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === null || Object.prototype.hasOwnProperty.call(prototype, "isPrototypeOf");
+}
+/** JSON.stringify that replaces circular references with "[Circular]". */
+function safeStringifyLite(value) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	return JSON.stringify(value, (_key, nested) => {
+		if (typeof nested === "object" && nested !== null) {
+			if (seen.has(nested)) return "[Circular]";
+			seen.add(nested);
+		}
+		return nested;
+	});
+}
+function isError(value) {
+	return typeof value === "object" && value !== null && "name" in value && "message" in value;
+}
+/** Turn a thrown value into an Error, as Next.js does before reporting it. */
+function getProperError(error) {
+	if (isError(error)) return error;
+	if (process.env.NODE_ENV === "development") {
+		if (typeof error === "undefined") return /* @__PURE__ */ new Error("An undefined error was thrown, see here for more info: https://nextjs.org/docs/messages/threw-undefined");
+		if (error === null) return /* @__PURE__ */ new Error("A null error was thrown, see here for more info: https://nextjs.org/docs/messages/threw-undefined");
+	}
+	return new Error(isPlainObject(error) ? safeStringifyLite(error) : String(error));
+}
+//#endregion
+export { getProperError };

package/dist/server/request-pipeline.d.ts

@@ -1,7 +1,7 @@
 import { INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS } from "./headers.js";
 import { hasBasePath, stripBasePath } from "../utils/base-path.js";
 import { StaticFileSignalContext, createStaticFileSignal } from "./static-file-signal.js";
-import { isOpenRedirectShaped } from "./open-redirect.js";
+import { getRepeatedSlashRedirect, isOpenRedirectShaped, sendRepeatedSlashRedirect } from "./open-redirect.js";
 //#region src/server/request-pipeline.d.ts
 /**
  * Apply the URL Standard's pathname canonicalization without decoding and
@@ -39,10 +39,21 @@ export declare function canonicalizeRequestUrlPathname(url: string): string;
  * Backslashes are equivalent to forward slashes in the URL spec
  * (e.g. `/\evil.com` is treated as `//evil.com` by browsers).
  *
- * Next.js returns 404 for these paths. We check the RAW pathname before
- * normalization so the guard fires before normalizePath collapses `//`.
- *
- * Percent-encoded variants are also blocked because:
+ * Like Next.js, any raw path containing a literal backslash or a repeated
+ * slash first gets a 308 to the collapsed path (`//evil.com` → `/evil.com`,
+ * `//` → `/`); see `getRepeatedSlashRedirect`. We check the RAW
+ * pathname before normalization so this fires before normalizePath collapses
+ * `//`.
+ *
+ * Request-based (Worker) entries only see `request.url` after WHATWG URL
+ * parsing, which has already turned `\` into `/`; the raw request target is
+ * not available there. `/\evil.com` still redirects (it arrives as
+ * `//evil.com`), but a lone backslash such as `/foo\bar` arrives as
+ * `/foo/bar` and is routed without the redirect. On Cloudflare, requests that
+ * match a static asset are also answered by the asset layer before the
+ * Worker runs. Node entries (dev and `vinext start`) check the raw target.
+ *
+ * Percent-encoded variants get a 404, as in Next.js, because:
  *   - `%5C` decodes to `\` (browsers treat `/\evil.com` as `//evil.com`).
  *   - `%2F` decodes to `/` (so `/%2F/evil.com` effectively becomes `//evil.com`).
  * These forms survive segment-wise decoding that re-encodes path delimiters
@@ -51,13 +62,17 @@ export declare function canonicalizeRequestUrlPathname(url: string): string;
  * `isOpenRedirectShaped` for the full list of rejected leading-segment forms.
  *
  * @param rawPathname - The raw pathname from the URL, before any normalization
- * @returns A 404 Response if the path is protocol-relative, or null to continue
+ * @param search - The raw query string (including `?`), kept in the 308 Location
+ * @returns A 308 or 404 Response, or null to continue
  */
-export declare function guardProtocolRelativeUrl(rawPathname: string): Response | null;
+export declare function guardProtocolRelativeUrl(rawPathname: string, search?: string): Response | null;
 export type HeaderRecord = Record<string, string | string[]>;
 type ResolvePublicFileRouteOptions = {
   cleanPathname: string;
-  middlewareContext: StaticFileSignalContext;
+  /** `requestHeaders` holds middleware's request-header override instructions. */
+  middlewareContext: StaticFileSignalContext & {
+    requestHeaders?: Headers | null;
+  };
   pathname: string;
   publicFiles: ReadonlySet<string>;
   request: Request;
@@ -175,4 +190,4 @@ export declare function cloneRequestWithHeaders(request: Request, headers: Heade
  */
 export declare function cloneRequestWithUrl(request: Request, url: string): Request;
 //#endregion
-export { INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS, createStaticFileSignal, hasBasePath, isOpenRedirectShaped, stripBasePath };
+export { INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS, createStaticFileSignal, getRepeatedSlashRedirect, hasBasePath, isOpenRedirectShaped, sendRepeatedSlashRedirect, stripBasePath };

package/dist/server/request-pipeline.js

@@ -1,9 +1,9 @@
 import "../utils/protocol-headers.js";
-import { getUnconsumedMiddlewareRequestHeaders } from "../utils/middleware-request-headers.js";
+import { buildRequestHeadersFromMiddlewareResponse, getUnconsumedMiddlewareRequestHeaders } from "../utils/middleware-request-headers.js";
 import { hasBasePath, removeTrailingSlash, stripBasePath } from "../utils/base-path.js";
 import { INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS } from "./headers.js";
 import { forbiddenResponse, methodNotAllowedResponse, notFoundResponse } from "./http-error-responses.js";
-import { isOpenRedirectShaped } from "./open-redirect.js";
+import { getRepeatedSlashRedirect, isOpenRedirectShaped, repeatedSlashRedirectResponse, sendRepeatedSlashRedirect } from "./open-redirect.js";
 import { createStaticFileSignal } from "./static-file-signal.js";
 //#region src/server/request-pipeline.ts
 const PATHNAME_CANONICALIZATION_BASE = new URL("http://vinext.invalid/");
@@ -52,10 +52,21 @@ function canonicalizeRequestUrlPathname(url) {
 * Backslashes are equivalent to forward slashes in the URL spec
 * (e.g. `/\evil.com` is treated as `//evil.com` by browsers).
 *
-* Next.js returns 404 for these paths. We check the RAW pathname before
-* normalization so the guard fires before normalizePath collapses `//`.
+* Like Next.js, any raw path containing a literal backslash or a repeated
+* slash first gets a 308 to the collapsed path (`//evil.com` → `/evil.com`,
+* `//` → `/`); see `getRepeatedSlashRedirect`. We check the RAW
+* pathname before normalization so this fires before normalizePath collapses
+* `//`.
 *
-* Percent-encoded variants are also blocked because:
+* Request-based (Worker) entries only see `request.url` after WHATWG URL
+* parsing, which has already turned `\` into `/`; the raw request target is
+* not available there. `/\evil.com` still redirects (it arrives as
+* `//evil.com`), but a lone backslash such as `/foo\bar` arrives as
+* `/foo/bar` and is routed without the redirect. On Cloudflare, requests that
+* match a static asset are also answered by the asset layer before the
+* Worker runs. Node entries (dev and `vinext start`) check the raw target.
+*
+* Percent-encoded variants get a 404, as in Next.js, because:
 *   - `%5C` decodes to `\` (browsers treat `/\evil.com` as `//evil.com`).
 *   - `%2F` decodes to `/` (so `/%2F/evil.com` effectively becomes `//evil.com`).
 * These forms survive segment-wise decoding that re-encodes path delimiters
@@ -64,9 +75,12 @@ function canonicalizeRequestUrlPathname(url) {
 * `isOpenRedirectShaped` for the full list of rejected leading-segment forms.
 *
 * @param rawPathname - The raw pathname from the URL, before any normalization
-* @returns A 404 Response if the path is protocol-relative, or null to continue
+* @param search - The raw query string (including `?`), kept in the 308 Location
+* @returns A 308 or 404 Response, or null to continue
 */
-function guardProtocolRelativeUrl(rawPathname) {
+function guardProtocolRelativeUrl(rawPathname, search = "") {
+	const slashRedirect = repeatedSlashRedirectResponse(rawPathname + search);
+	if (slashRedirect) return slashRedirect;
 	if (isOpenRedirectShaped(rawPathname)) return notFoundResponse();
 	return null;
 }
@@ -86,7 +100,8 @@ function resolvePublicFileRoute(options) {
 	if (options.pathname.endsWith(".rsc")) return null;
 	if (!options.publicFiles.has(options.cleanPathname)) return null;
 	if (options.request.method !== "GET" && options.request.method !== "HEAD") return methodNotAllowedResponse("GET, HEAD", { headers: options.middlewareContext.headers ?? void 0 });
-	return createStaticFileSignal(options.cleanPathname, options.middlewareContext);
+	const { requestHeaders } = options.middlewareContext;
+	return createStaticFileSignal(options.cleanPathname, options.middlewareContext, requestHeaders ? buildRequestHeadersFromMiddlewareResponse(options.request.headers, requestHeaders) : null);
 }
 function normalizeTrailingSlashPathname(pathname, trailingSlash) {
 	if (pathname === "/" || pathname === "/api" || pathname.startsWith("/api/")) return null;
@@ -418,4 +433,4 @@ function cloneRequestWithUrl(request, url) {
 	return attachRequestCfMetadata(cloned, request);
 }
 //#endregion
-export { INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS, attachRequestCfMetadata, canonicalizeRequestPathname, canonicalizeRequestUrlPathname, cloneRequestWithHeaders, cloneRequestWithUrl, createStaticFileSignal, filterInternalHeaders, guardProtocolRelativeUrl, hasBasePath, isOpenRedirectShaped, isOriginAllowed, normalizeTrailingSlash, normalizeTrailingSlashPathname, processMiddlewareHeaders, resolvePublicFileRoute, stripBasePath, validateCsrfOrigin, validateServerActionPayload };
+export { INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS, attachRequestCfMetadata, canonicalizeRequestPathname, canonicalizeRequestUrlPathname, cloneRequestWithHeaders, cloneRequestWithUrl, createStaticFileSignal, filterInternalHeaders, getRepeatedSlashRedirect, guardProtocolRelativeUrl, hasBasePath, isOpenRedirectShaped, isOriginAllowed, normalizeTrailingSlash, normalizeTrailingSlashPathname, processMiddlewareHeaders, resolvePublicFileRoute, sendRepeatedSlashRedirect, stripBasePath, validateCsrfOrigin, validateServerActionPayload };

package/dist/server/response-compression.d.ts

@@ -0,0 +1,43 @@
+import { NegotiatedEncoding } from "./accept-encoding.js";
+import { IncomingMessage } from "node:http";
+//#region src/server/response-compression.d.ts
+/**
+ * Whether a Content-Type is compressible, matching `compressible()`. This
+ * covers `text/x-component` (RSC payloads) through the `text/` rule.
+ */
+export declare function isCompressibleContentType(contentType: string | null | undefined): boolean;
+/** Whether a Cache-Control value forbids content codings (`no-transform`). */
+export declare function hasNoTransform(cacheControl: string | null | undefined): boolean;
+/** Responses whose known length is below this many bytes are sent uncompressed. */
+export declare const COMPRESS_THRESHOLD = 1024;
+export type ResponseCompressionHeaders = {
+  contentType: string | null | undefined;
+  cacheControl: string | null | undefined;
+  contentEncoding: string | null | undefined;
+  /**
+   * Body length in bytes when it is known before the headers are written (a
+   * Content-Length header, or a buffered or empty body). Undefined for
+   * streamed bodies, which are compressed regardless of size.
+   */
+  contentLength: number | undefined;
+};
+export type ResponseCompression = {
+  /** Whether the response must carry `Vary: Accept-Encoding`. */
+  varyAcceptEncoding: boolean;
+  /** The coding to apply. `identity` sends the body as is. */
+  encoding: NegotiatedEncoding;
+};
+/**
+ * Decide how to compress a response, in the middleware's order: the
+ * Content-Type filter and `Cache-Control: no-transform` skip compression
+ * without `Vary`; every other response gets `Vary: Accept-Encoding`, then is
+ * sent uncompressed when it is under the size threshold, already encoded, or
+ * a HEAD response, or when the client accepts no supported coding.
+ *
+ * Unlike the middleware, which offers only gzip and deflate, negotiation also
+ * offers zstd and br (see negotiateEncoding).
+ */
+export declare function resolveResponseCompression(req: IncomingMessage, compress: boolean, headers: ResponseCompressionHeaders): ResponseCompression;
+/** Parse a Content-Length header value the way the middleware compares it. */
+export declare function parseContentLengthHeader(value: string | null | undefined): number | undefined;
+//#endregion

package/dist/server/response-compression.js

@@ -0,0 +1,111 @@
+import { negotiateEncoding } from "./accept-encoding.js";
+//#region src/server/response-compression.ts
+/**
+* Response compression rules for the Node production server, ported from the
+* `compression` middleware that `next start` installs for every response
+* unless `compress: false` (next/dist/compiled/compression, see
+* packages/next/src/server/lib/router-server.ts).
+*/
+const EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
+const COMPRESSIBLE_TYPE_REGEXP = /^text\/|\+(?:json|text|xml)$/i;
+/**
+* mime-db entries marked `compressible: true` that COMPRESSIBLE_TYPE_REGEXP
+* does not match, taken from the mime-db bundled with Next.js's compression
+* middleware. That mime-db marks no type `compressible: false` that the
+* regexp matches, so this set plus the regexp reproduces `compressible()`.
+*/
+const MIME_DB_COMPRESSIBLE_TYPES = /* @__PURE__ */ new Set([
+	"application/dart",
+	"application/ecmascript",
+	"application/javascript",
+	"application/json",
+	"application/postscript",
+	"application/raml+yaml",
+	"application/rtf",
+	"application/tar",
+	"application/toml",
+	"application/vnd.dart",
+	"application/vnd.ms-fontobject",
+	"application/vnd.ms-opentype",
+	"application/wasm",
+	"application/x-httpd-php",
+	"application/x-javascript",
+	"application/x-ns-proxy-autoconfig",
+	"application/x-sh",
+	"application/x-tar",
+	"application/x-virtualbox-hdd",
+	"application/x-virtualbox-ova",
+	"application/x-virtualbox-ovf",
+	"application/x-virtualbox-vbox",
+	"application/x-virtualbox-vdi",
+	"application/x-virtualbox-vhd",
+	"application/x-virtualbox-vmdk",
+	"application/x-www-form-urlencoded",
+	"application/xml",
+	"application/xml-dtd",
+	"font/otf",
+	"font/ttf",
+	"image/bmp",
+	"image/vnd.adobe.photoshop",
+	"image/x-icon",
+	"image/x-ms-bmp",
+	"message/rfc822",
+	"model/gltf-binary",
+	"x-shader/x-fragment",
+	"x-shader/x-vertex"
+]);
+/**
+* Whether a Content-Type is compressible, matching `compressible()`. This
+* covers `text/x-component` (RSC payloads) through the `text/` rule.
+*/
+function isCompressibleContentType(contentType) {
+	if (!contentType) return false;
+	const match = EXTRACT_TYPE_REGEXP.exec(contentType);
+	const mime = match ? match[1].toLowerCase() : "";
+	return MIME_DB_COMPRESSIBLE_TYPES.has(mime) || COMPRESSIBLE_TYPE_REGEXP.test(mime);
+}
+const NO_TRANSFORM_REGEXP = /(?:^|,)\s*?no-transform\s*?(?:,|$)/;
+/** Whether a Cache-Control value forbids content codings (`no-transform`). */
+function hasNoTransform(cacheControl) {
+	return !!cacheControl && NO_TRANSFORM_REGEXP.test(cacheControl);
+}
+/** Responses whose known length is below this many bytes are sent uncompressed. */
+const COMPRESS_THRESHOLD = 1024;
+const NO_COMPRESSION = {
+	varyAcceptEncoding: false,
+	encoding: "identity"
+};
+/**
+* Decide how to compress a response, in the middleware's order: the
+* Content-Type filter and `Cache-Control: no-transform` skip compression
+* without `Vary`; every other response gets `Vary: Accept-Encoding`, then is
+* sent uncompressed when it is under the size threshold, already encoded, or
+* a HEAD response, or when the client accepts no supported coding.
+*
+* Unlike the middleware, which offers only gzip and deflate, negotiation also
+* offers zstd and br (see negotiateEncoding).
+*/
+function resolveResponseCompression(req, compress, headers) {
+	if (!compress) return NO_COMPRESSION;
+	if (!isCompressibleContentType(headers.contentType)) return NO_COMPRESSION;
+	if (hasNoTransform(headers.cacheControl)) return NO_COMPRESSION;
+	const identity = {
+		varyAcceptEncoding: true,
+		encoding: "identity"
+	};
+	if (headers.contentLength !== void 0 && headers.contentLength < 1024) return identity;
+	if ((headers.contentEncoding || "identity") !== "identity") return identity;
+	if (req.method === "HEAD") return identity;
+	return {
+		varyAcceptEncoding: true,
+		encoding: negotiateEncoding(req)
+	};
+}
+/** Parse a Content-Length header value the way the middleware compares it. */
+function parseContentLengthHeader(value) {
+	if (value === null || value === void 0) return void 0;
+	const length = Number(value);
+	return Number.isNaN(length) ? void 0 : length;
+}
+//#endregion
+export { COMPRESS_THRESHOLD, hasNoTransform, isCompressibleContentType, parseContentLengthHeader, resolveResponseCompression };

package/dist/server/revalidation-request.d.ts

@@ -1,6 +1,7 @@
 import { PRERENDER_REVALIDATE_HEADER } from "../utils/protocol-headers.js";
 //#region src/server/revalidation-request.d.ts
 export declare function getRevalidateSecret(): string;
+export declare function safeEqual(first: string, second: string): boolean;
 export declare function isRevalidateSecret(value: string | null | undefined): boolean;
 /** Match Next.js: the header value must equal the preview/revalidation secret. */
 export declare function isOnDemandRevalidateRequest(headerValue: string | string[] | null | undefined): boolean;

package/dist/server/revalidation-request.js

@@ -34,4 +34,4 @@ function isOnDemandRevalidateRequest(headerValue) {
 	return typeof headerValue === "string" && isRevalidateSecret(headerValue);
 }
 //#endregion
-export { PRERENDER_REVALIDATE_HEADER, getRevalidateSecret, isOnDemandRevalidateRequest, isRevalidateSecret };
+export { PRERENDER_REVALIDATE_HEADER, getRevalidateSecret, isOnDemandRevalidateRequest, isRevalidateSecret, safeEqual };

package/dist/server/rsc-stream-hints.js

@@ -55,6 +55,15 @@ function indexOfByte(bytes, byte, from) {
 	for (let index = from; index < bytes.byteLength; index++) if (bytes[index] === byte) return index;
 	return -1;
 }
+function utf8CompleteEnd(bytes, from) {
+	const length = bytes.byteLength;
+	for (let index = length - 1; index >= from && index >= length - 3; index--) {
+		const byte = bytes[index];
+		if ((byte & 192) === 128) continue;
+		return index + (byte >= 240 ? 4 : byte >= 224 ? 3 : byte >= 192 ? 2 : 1) > length ? index : length;
+	}
+	return length;
+}
 function parseHexBytes(bytes, start, end) {
 	if (start === end) return null;
 	let value = 0;
@@ -101,16 +110,30 @@ function normalizeReactFlightPreloadHints(stream) {
 	let carry = null;
 	let rawBytesRemaining = 0;
 	let passThrough = false;
+	let inPlainRow = false;
 	return stream.pipeThrough(new TransformStream({
 		transform(chunk, controller) {
 			if (passThrough) {
 				controller.enqueue(chunk);
 				return;
 			}
+			let start = 0;
+			if (inPlainRow) {
+				const end = indexOfByte(chunk, NEWLINE_BYTE, 0);
+				if (end === -1) {
+					const bytes = carry === null ? chunk : concatBytes(carry, chunk);
+					const complete = utf8CompleteEnd(bytes, 0);
+					carry = complete === bytes.byteLength ? null : bytes.slice(complete);
+					if (complete > 0) controller.enqueue(complete === bytes.byteLength ? bytes : bytes.subarray(0, complete));
+					return;
+				}
+				inPlainRow = false;
+				start = (carry === null ? 0 : carry.byteLength) + end + 1;
+			}
 			const bytes = carry === null ? chunk : concatBytes(carry, chunk);
 			carry = null;
 			const byteLength = bytes.byteLength;
-			let offset = 0;
+			let offset = start;
 			let emittedThrough = 0;
 			let output = bytes;
 			let ownsOutput = bytes !== chunk;
@@ -146,7 +169,13 @@ function normalizeReactFlightPreloadHints(stream) {
 					break;
 				}
 				const newline = indexOfByte(bytes, NEWLINE_BYTE, offset);
-				if (newline === -1) break;
+				if (newline === -1) {
+					if (!(tagByte === HINT_TAG_BYTE && (colon + 2 === byteLength || bytes[colon + 2] === LINK_HINT_CODE_BYTE))) {
+						inPlainRow = true;
+						offset = utf8CompleteEnd(bytes, offset);
+					}
+					break;
+				}
 				if (tagByte === HINT_TAG_BYTE && bytes[colon + 2] === LINK_HINT_CODE_BYTE) {
 					const line = bytes.subarray(offset, newline + 1);
 					const normalized = normalizeReactFlightHintLine(line);

package/dist/server/seed-cache.d.ts

@@ -14,6 +14,7 @@ type PrerenderCacheSeedMetadata = {
 };
 type PrerenderCacheSeedOptions = {
   buildAppPageHtmlKey?: (pathname: string) => string;
+  buildAppPageFallbackShellKey?: (pathname: string, suffix: "html" | "rsc") => string;
   buildAppPageRscKey?: (pathname: string) => string;
   buildAppRouteKey?: (pathname: string) => string;
   writeAppPageEntry?: (key: string, data: CachedAppPageValue, metadata: PrerenderCacheSeedMetadata) => Promise<void>;

package/dist/server/seed-cache.js

@@ -1,5 +1,5 @@
 import path from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
-import { appIsrCacheKey, isrSet, isrSetPrerenderedAppPage } from "./isr-cache.js";
+import { appIsrCacheKey, appIsrFallbackShellKey, isrSet, isrSetPrerenderedAppPage } from "./isr-cache.js";
 import { addPregeneratedConcretePath, addPregeneratedRoute, clearPregeneratedConcretePaths, normalizePregeneratedPathname } from "./pregenerated-concrete-paths.js";
 import { getRenderedAppRoutes, getRenderedMetadataRoutes, isFallbackShellArtifactPath, readPrerenderManifest } from "./prerender-manifest.js";
 import { buildAppPageCacheTags, buildAppRouteCacheTags } from "./app-page-cache.js";
@@ -61,17 +61,21 @@ async function seedMemoryCacheFromPrerender(serverDir, options) {
 	const appRoutes = getRenderedAppRoutes(routes);
 	for (const route of appRoutes) {
 		const concretePathname = route.path ?? route.route;
-		if (!isFallbackShellArtifactPath(concretePathname, route)) addPregeneratedConcretePath(route.route, concretePathname);
+		const isFallbackShell = isFallbackShellArtifactPath(concretePathname, route);
+		if (!isFallbackShell) addPregeneratedConcretePath(route.route, concretePathname);
 		const artifactPathname = route.path ?? route.route;
 		const cachePathname = normalizePregeneratedPathname(artifactPathname);
-		const htmlKey = options?.buildAppPageHtmlKey?.(cachePathname) ?? appIsrCacheKey(cachePathname, "html", buildId);
-		const rscKey = options?.buildAppPageRscKey?.(cachePathname) ?? appIsrCacheKey(cachePathname, "rsc", buildId);
+		const htmlKey = isFallbackShell ? options?.buildAppPageFallbackShellKey?.(cachePathname, "html") ?? appIsrFallbackShellKey(cachePathname, "html", buildId) : options?.buildAppPageHtmlKey?.(cachePathname) ?? appIsrCacheKey(cachePathname, "html", buildId);
+		const rscKey = isFallbackShell ? options?.buildAppPageFallbackShellKey?.(cachePathname, "rsc") ?? appIsrFallbackShellKey(cachePathname, "rsc", buildId) : options?.buildAppPageRscKey?.(cachePathname) ?? appIsrCacheKey(cachePathname, "rsc", buildId);
 		const revalidateSeconds = typeof route.revalidate === "number" ? route.revalidate : void 0;
 		const expireSeconds = typeof route.expire === "number" ? route.expire : void 0;
 		const staleSeconds = typeof route.stale === "number" && route.stale >= 0 ? route.stale : void 0;
 		const tags = buildAppPageCacheTags(cachePathname, route.tags ?? []);
-		if (await seedHtml(writeAppPageEntry, prerenderDir, htmlKey, artifactPathname, trailingSlash, route.headers, revalidateSeconds, expireSeconds, staleSeconds, tags)) {
-			await seedRsc(writeAppPageEntry, prerenderDir, rscKey, artifactPathname, revalidateSeconds, expireSeconds, staleSeconds, tags);
+		const status = route.responseStatus;
+		const location = route.headers?.location;
+		const rscHeaders = status !== void 0 && location !== void 0 ? { location } : void 0;
+		if (await seedHtml(writeAppPageEntry, prerenderDir, htmlKey, artifactPathname, trailingSlash, route.headers, status, revalidateSeconds, expireSeconds, staleSeconds, tags)) {
+			await seedRsc(writeAppPageEntry, prerenderDir, rscKey, artifactPathname, rscHeaders, status, revalidateSeconds, expireSeconds, staleSeconds, tags);
 			seeded++;
 		}
 	}
@@ -107,7 +111,7 @@ function createDefaultAppPageEntryWriter() {
 * Seed the HTML cache entry for a single route.
 * Returns true if the file existed and was seeded.
 */
-async function seedHtml(writeAppPageEntry, prerenderDir, key, pathname, trailingSlash, headers, revalidateSeconds, expireSeconds, staleSeconds, tags) {
+async function seedHtml(writeAppPageEntry, prerenderDir, key, pathname, trailingSlash, headers, status, revalidateSeconds, expireSeconds, staleSeconds, tags) {
 	const relPath = getOutputPath(pathname, trailingSlash);
 	const fullPath = path.join(prerenderDir, relPath);
 	if (!fs.existsSync(fullPath)) return false;
@@ -117,7 +121,7 @@ async function seedHtml(writeAppPageEntry, prerenderDir, key, pathname, trailing
 		rscData: void 0,
 		headers,
 		postponed: void 0,
-		status: void 0
+		status
 	}, {
 		expireSeconds,
 		revalidateSeconds,
@@ -130,7 +134,7 @@ async function seedHtml(writeAppPageEntry, prerenderDir, key, pathname, trailing
 * Seed the RSC cache entry for a single route.
 * No-op if the .rsc file doesn't exist on disk.
 */
-async function seedRsc(writeAppPageEntry, prerenderDir, key, pathname, revalidateSeconds, expireSeconds, staleSeconds, tags) {
+async function seedRsc(writeAppPageEntry, prerenderDir, key, pathname, headers, status, revalidateSeconds, expireSeconds, staleSeconds, tags) {
 	const relPath = getRscOutputPath(pathname);
 	const fullPath = path.join(prerenderDir, relPath);
 	if (!fs.existsSync(fullPath)) return;
@@ -139,9 +143,9 @@ async function seedRsc(writeAppPageEntry, prerenderDir, key, pathname, revalidat
 		kind: "APP_PAGE",
 		html: "",
 		rscData: rscBuffer.buffer.slice(rscBuffer.byteOffset, rscBuffer.byteOffset + rscBuffer.byteLength),
-		headers: void 0,
+		headers,
 		postponed: void 0,
-		status: void 0
+		status
 	}, {
 		expireSeconds,
 		revalidateSeconds,

package/dist/server/server-reference-loader.d.ts

@@ -0,0 +1,4 @@
+//#region src/server/server-reference-loader.d.ts
+/** Wrap plugin-rsc's server-reference loader once; must run after it is installed. */
+export declare function isolateServerReferenceLoads(): void;
+//#endregion

package/dist/server/server-reference-loader.js

@@ -0,0 +1,29 @@
+import { runOutsideRequestScopes } from "../shims/internal/als-registry.js";
+//#region src/server/server-reference-loader.ts
+/**
+* Keep server-reference module evaluation out of the request that first
+* names the module.
+*
+* React resolves every server reference it decodes through
+* `@vitejs/plugin-rsc`'s `globalThis.__vite_rsc_server_require__`, which
+* imports the referenced module on first use. Some references are resolved
+* only once the action consumes them — promise and async-iterable arguments,
+* and the encrypted closure captures an inline action decrypts in its own
+* body — so they load inside the caller's request, past the loads the action
+* dispatcher already runs outside it. A dynamic `import()` carries
+* AsyncLocalStorage into the module's top-level evaluation, so module-scope
+* `cookies()`/`headers()` would capture that caller's request for every later
+* caller in the isolate. Next.js evaluates action modules outside the request
+* store, where those calls throw.
+*/
+const ISOLATED = Symbol.for("vinext.serverReferenceRequire.isolated");
+/** Wrap plugin-rsc's server-reference loader once; must run after it is installed. */
+function isolateServerReferenceLoads() {
+	const load = globalThis.__vite_rsc_server_require__;
+	if (typeof load !== "function" || ISOLATED in load) return;
+	const isolated = (id) => runOutsideRequestScopes(() => load(id));
+	Object.defineProperty(isolated, ISOLATED, { value: true });
+	globalThis.__vite_rsc_server_require__ = isolated;
+}
+//#endregion
+export { isolateServerReferenceLoads };

package/dist/server/socket-error-backstop.d.ts

@@ -23,11 +23,33 @@ export declare function peerDisconnectCode(err: unknown): string | undefined;
  * Exported for unit testing in isolation.
  */
 export declare function isBenignAssetImportError(err: unknown): boolean;
+/**
+ * Pure predicate: returns `true` when `err` is Node's
+ * `Readable.toWeb()` adapter enqueueing into a request body stream that was
+ * already cancelled. `pull()` calls `req.resume()`, which schedules `flow()`
+ * on `nextTick`; if the body is cancelled before that tick runs, `flow()`
+ * still emits the chunks already buffered in `req` and the adapter's
+ * `onData` throws inside the `nextTick` callback. srvx (used by
+ * `@vitejs/plugin-rsc` in dev) builds `request.body` this way, so any
+ * cancelled request body, e.g. an oversized Server Action, can crash the
+ * dev server. Node main drops that data instead (`if (wasCanceled) return;`
+ * in `onData`), so absorbing it matches upstream behaviour. Exported for
+ * unit testing in isolation.
+ */
+export declare function isCancelledRequestBodyEnqueueError(err: unknown): boolean;
 /**
  * Test-only: returns whether the backstop has been installed in this
  * process. Used by the unit test to assert idempotent install via the
  * Symbol.for guard. Not part of the public API.
  */
 export declare function isSocketErrorBackstopInstalled(): boolean;
-export declare function installSocketErrorBackstop(): void;
+/**
+ * Installs the backstop once per process. Pass `{ runningServer: true }`
+ * from a long-lived production server to log, rather than re-throw,
+ * errors outside the absorbed set. The flag is process-global and sticky,
+ * so it also applies when `index.ts` installed the listeners first.
+ */
+export declare function installSocketErrorBackstop(options?: {
+  runningServer?: boolean;
+}): void;
 //#endregion