vinext 1.0.1 → 1.2.0

package/dist/server/socket-error-backstop.js

@@ -1,9 +1,10 @@
 //#region src/server/socket-error-backstop.ts
 /**
-* Process-level backstop for peer-disconnect errors that escape
-* per-connection / per-request error guards.
+* Process-level backstop for errors that escape per-connection /
+* per-request error guards.
 *
-* Three real call sites in vinext that hit this:
+* Three real call sites in vinext that hit this with peer-disconnect
+* errors:
 *   - `fromWeb(fetch().body).pipe(res)` in proxyExternalRewriteNode.
 *   - Streaming surfaces inside `@vitejs/plugin-rsc` with their own
 *     pipe topology (destinations aren't inbound connection sockets).
@@ -14,13 +15,25 @@
 * inside a `nextTick` callback. The throw escapes to
 * `uncaughtException`, where this listener filters it.
 *
-* Filters strictly on peer-disconnect codes (ECONNRESET / EPIPE /
-* ECONNABORTED) plus benign static-asset `import()` rejections (see
-* `isBenignAssetImportError`), and synchronously re-throws everything
-* else, preserving Node's default crash semantics for genuine bugs.
-* This is more conservative than Next.js's equivalent
-* (`router-server.ts`'s log-only handler), which silently swallows
-* every uncaught — vinext keeps real bugs surfacing.
+* Always absorbs benign static-asset `import()` rejections (see
+* `isBenignAssetImportError`). Outside prerender it also silently
+* absorbs peer-disconnect codes (ECONNRESET / EPIPE / ECONNABORTED) and
+* Node's cancelled-request-body enqueue race (see
+* `isCancelledRequestBodyEnqueueError`). Everything else depends on the
+* phase:
+*
+*   - **Running server** (`vite dev`, `vinext start`, standalone
+*     `server.js`): logged and absorbed, matching the log-only
+*     `uncaughtException` / `unhandledRejection` handlers that Next.js's
+*     `router-server.ts` installs for both `next dev` and `next start`.
+*     App code may legitimately leave a rejection unhandled for a few
+*     ticks (Next.js's documented "Preloading data" pattern,
+*     fire-and-forget calls), and request input can often choose whether
+*     it rejects, so crashing would let one anonymous request take down
+*     the whole process. The dev server's `configureServer` hook and
+*     `startProdServer()` opt in via `{ runningServer: true }`.
+*   - **Build and prerender**: synchronously re-thrown, preserving
+*     Node's default crash semantics.
 *
 * **Installed at module load.** Earlier iterations tried to gate
 * install via Vite's `config()` hook (`command === "serve"`) so it
@@ -66,11 +79,12 @@
 * top of every user's `vite.config.ts`, so vinext's listener registers
 * before most user / tooling listeners (Sentry, OpenTelemetry,
 * structured logging). For peer-disconnect codes the early-return is
-* fine. For non-peer-disconnect errors the synchronous re-throw still
-* crashes the process with the original stack, but listeners
-* registered after vinext don't observe the event. Users who need
-* crash-reporter visibility for non-peer-disconnect errors must
-* register their handler before importing vinext.
+* fine, and on a running production server every other error is
+* logged without throwing, so later listeners still observe it. In
+* the re-throw phases the synchronous re-throw still crashes the
+* process with the original stack, but listeners registered after
+* vinext don't observe the event. Users who need crash-reporter
+* visibility there must register their handler before importing vinext.
 *
 * **Symbol.for caveat.** `Symbol.for("vinext.socketErrorBackstop")`
 * is process-global, so if two different vinext versions are loaded
@@ -81,6 +95,7 @@
 * time the listener absorbs an error.
 */
 const SOCKET_BACKSTOP_FLAG = Symbol.for("vinext.socketErrorBackstop");
+const RUNNING_SERVER_FLAG = Symbol.for("vinext.socketErrorBackstop.runningServer");
 /**
 * Pure predicate: returns the peer-disconnect code when `err` carries
 * one of `ECONNRESET` / `EPIPE` / `ECONNABORTED`, otherwise `undefined`.
@@ -153,6 +168,24 @@ function isBenignAssetImportError(err) {
 	return false;
 }
 /**
+* 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.
+*/
+function isCancelledRequestBodyEnqueueError(err) {
+	if (err === null || typeof err !== "object") return false;
+	const { code, message, stack } = err;
+	return code === "ERR_INVALID_STATE" && typeof message === "string" && message.includes("Controller is already closed") && typeof stack === "string" && /\.onData \(node:internal\/webstreams\/adapters:\d+/.test(stack);
+}
+/**
 * 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.
@@ -160,8 +193,15 @@ function isBenignAssetImportError(err) {
 function isSocketErrorBackstopInstalled() {
 	return Boolean(process[SOCKET_BACKSTOP_FLAG]);
 }
-function installSocketErrorBackstop() {
+/**
+* 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.
+*/
+function installSocketErrorBackstop(options = {}) {
 	const proc = process;
+	if (options.runningServer) proc[RUNNING_SERVER_FLAG] = true;
 	if (proc[SOCKET_BACKSTOP_FLAG]) return;
 	if (process.env.VITEST === "true" || process.env.NODE_ENV === "test") return;
 	proc[SOCKET_BACKSTOP_FLAG] = true;
@@ -183,6 +223,14 @@ function installSocketErrorBackstop() {
 			if (debug) console.warn(`[vinext] absorbed uncaughtException ${code}`);
 			return;
 		}
+		if (isCancelledRequestBodyEnqueueError(err)) {
+			if (debug) console.warn("[vinext] absorbed uncaughtException ERR_INVALID_STATE (cancelled request body)");
+			return;
+		}
+		if (proc[RUNNING_SERVER_FLAG]) {
+			console.error("[vinext] uncaughtException:", err);
+			return;
+		}
 		throw err;
 	});
 	process.on("unhandledRejection", (reason) => {
@@ -193,8 +241,12 @@ function installSocketErrorBackstop() {
 			if (debug) console.warn(`[vinext] absorbed unhandledRejection ${code}`);
 			return;
 		}
+		if (proc[RUNNING_SERVER_FLAG]) {
+			console.error("[vinext] unhandledRejection:", reason);
+			return;
+		}
 		throw reason;
 	});
 }
 //#endregion
-export { installSocketErrorBackstop, isBenignAssetImportError, isSocketErrorBackstopInstalled, peerDisconnectCode };
+export { installSocketErrorBackstop, isBenignAssetImportError, isCancelledRequestBodyEnqueueError, isSocketErrorBackstopInstalled, peerDisconnectCode };

package/dist/server/static-file-signal.d.ts

@@ -3,14 +3,25 @@ export type StaticFileSignalContext = {
   headers: Headers | null;
   status: number | null;
 };
-/** Create the only response shape that host runtimes may resolve as an asset. */
-export declare function createStaticFileSignal(pathname: string, context: StaticFileSignalContext): Response;
+/**
+ * Create the only response shape that host runtimes may resolve as an asset.
+ * `requestHeaders` are the request headers after middleware's overrides, which
+ * the asset fetch uses in place of the original request's headers.
+ */
+export declare function createStaticFileSignal(pathname: string, context: StaticFileSignalContext, requestHeaders?: Headers | null): Response;
 /** Whether this response was created by vinext's public-file router. */
 export declare function isStaticFileSignal(response: Response): boolean;
 /** Return the encoded asset pathname only for a framework-created signal. */
 export declare function readStaticFileSignal(response: Response): string | null;
-/** Encode a framework-authenticated signal for a standards-only stage transport. */
+/** Return the post-middleware request headers a framework-created signal carries. */
+export declare function readStaticFileSignalRequestHeaders(response: Response): Headers | null;
+/**
+ * Encode a framework-authenticated signal for a standards-only stage transport.
+ * Post-middleware request headers travel in the body, which has no platform
+ * size limit, rather than in a response header. Their marker header carries
+ * the real status, since the body needs a status that allows one.
+ */
 export declare function serializeStaticFileSignalForTransport(response: Response, token: string): Response;
 /** Restore and consume a signal returned by the trusted response-stage wrapper. */
-export declare function restoreStaticFileSignalFromTransport(response: Response, token: string): Response;
+export declare function restoreStaticFileSignalFromTransport(response: Response, token: string): Promise<Response>;
 //#endregion

package/dist/server/static-file-signal.js

@@ -1,6 +1,8 @@
 //#region src/server/static-file-signal.ts
 const STATIC_FILE_SIGNAL = Symbol.for("vinext.static-file-signal");
+const STATIC_FILE_REQUEST_HEADERS = Symbol.for("vinext.static-file-request-headers");
 const STATIC_FILE_SIGNAL_TRANSPORT_HEADER = "x-vinext-stage-static-file";
+const STATIC_FILE_REQUEST_HEADERS_TRANSPORT_HEADER = "x-vinext-stage-static-file-request-headers";
 const STATIC_FILE_REPRESENTATION_HEADERS = [
 	"content-encoding",
 	"content-length",
@@ -14,17 +16,19 @@ const STATIC_FILE_REPRESENTATION_HEADERS = [
 * before the host runtime can fetch the asset. Application response headers
 * remain ordinary metadata and cannot alter framework control flow.
 */
-function markStaticFileSignal(response, pathname) {
-	return markEncodedStaticFileSignal(response, encodeURIComponent(pathname));
+function markStaticFileSignal(response, pathname, requestHeaders) {
+	return markEncodedStaticFileSignal(response, encodeURIComponent(pathname), requestHeaders);
 }
-function markEncodedStaticFileSignal(response, encodedPathname) {
+function markEncodedStaticFileSignal(response, encodedPathname, requestHeaders) {
 	Object.defineProperty(response, STATIC_FILE_SIGNAL, { value: encodedPathname });
+	if (requestHeaders) Object.defineProperty(response, STATIC_FILE_REQUEST_HEADERS, { value: requestHeaders });
 	return response;
 }
 function withoutTransportHeader(response) {
-	if (!response.headers.has(STATIC_FILE_SIGNAL_TRANSPORT_HEADER)) return response;
+	if (!response.headers.has(STATIC_FILE_SIGNAL_TRANSPORT_HEADER) && !response.headers.has(STATIC_FILE_REQUEST_HEADERS_TRANSPORT_HEADER)) return response;
 	const headers = new Headers(response.headers);
 	headers.delete(STATIC_FILE_SIGNAL_TRANSPORT_HEADER);
+	headers.delete(STATIC_FILE_REQUEST_HEADERS_TRANSPORT_HEADER);
 	if (response.status < 200 || response.status > 599) return response;
 	const body = response.status === 204 || response.status === 205 || response.status === 304 ? null : response.body;
 	return new Response(body, {
@@ -33,14 +37,18 @@ function withoutTransportHeader(response) {
 		statusText: response.statusText
 	});
 }
-/** Create the only response shape that host runtimes may resolve as an asset. */
-function createStaticFileSignal(pathname, context) {
+/**
+* Create the only response shape that host runtimes may resolve as an asset.
+* `requestHeaders` are the request headers after middleware's overrides, which
+* the asset fetch uses in place of the original request's headers.
+*/
+function createStaticFileSignal(pathname, context, requestHeaders = null) {
 	const headers = new Headers();
 	if (context.headers) for (const [key, value] of context.headers) headers.append(key, value);
 	return markStaticFileSignal(new Response(null, {
 		status: context.status ?? 200,
 		headers
-	}), pathname);
+	}), pathname, requestHeaders);
 }
 /** Whether this response was created by vinext's public-file router. */
 function isStaticFileSignal(response) {
@@ -51,22 +59,40 @@ function readStaticFileSignal(response) {
 	const signal = Reflect.get(response, STATIC_FILE_SIGNAL);
 	return typeof signal === "string" ? signal : null;
 }
-/** Encode a framework-authenticated signal for a standards-only stage transport. */
+/** Return the post-middleware request headers a framework-created signal carries. */
+function readStaticFileSignalRequestHeaders(response) {
+	const headers = Reflect.get(response, STATIC_FILE_REQUEST_HEADERS);
+	return headers instanceof Headers ? headers : null;
+}
+function isHeaderEntries(value) {
+	return Array.isArray(value) && value.every((entry) => Array.isArray(entry) && entry.length === 2 && typeof entry[0] === "string" && typeof entry[1] === "string");
+}
+/**
+* Encode a framework-authenticated signal for a standards-only stage transport.
+* Post-middleware request headers travel in the body, which has no platform
+* size limit, rather than in a response header. Their marker header carries
+* the real status, since the body needs a status that allows one.
+*/
 function serializeStaticFileSignalForTransport(response, token) {
 	const signal = readStaticFileSignal(response);
 	if (signal === null) return response;
 	const headers = new Headers(response.headers);
 	for (const name of STATIC_FILE_REPRESENTATION_HEADERS) headers.delete(name);
+	headers.delete(STATIC_FILE_REQUEST_HEADERS_TRANSPORT_HEADER);
 	headers.set(STATIC_FILE_SIGNAL_TRANSPORT_HEADER, `${token}:${signal}`);
-	return new Response(null, {
+	const requestHeaders = readStaticFileSignalRequestHeaders(response);
+	if (!requestHeaders) return new Response(null, {
 		headers,
 		status: response.status,
 		statusText: response.statusText
 	});
+	headers.set(STATIC_FILE_REQUEST_HEADERS_TRANSPORT_HEADER, `${token}:${response.status}`);
+	return new Response(JSON.stringify([...requestHeaders]), { headers });
 }
 /** Restore and consume a signal returned by the trusted response-stage wrapper. */
-function restoreStaticFileSignalFromTransport(response, token) {
+async function restoreStaticFileSignalFromTransport(response, token) {
 	const transported = response.headers.get(STATIC_FILE_SIGNAL_TRANSPORT_HEADER);
+	const requestHeadersMarker = response.headers.get(STATIC_FILE_REQUEST_HEADERS_TRANSPORT_HEADER);
 	const cleaned = withoutTransportHeader(response);
 	const prefix = `${token}:`;
 	if (transported === null || !transported.startsWith(prefix)) return cleaned;
@@ -76,7 +102,15 @@ function restoreStaticFileSignalFromTransport(response, token) {
 	} catch {
 		return cleaned;
 	}
-	return markEncodedStaticFileSignal(cleaned, encodedPathname);
+	if (requestHeadersMarker === null) return markEncodedStaticFileSignal(cleaned, encodedPathname, null);
+	const status = Number(requestHeadersMarker.startsWith(prefix) ? requestHeadersMarker.slice(prefix.length) : NaN);
+	if (!Number.isInteger(status) || status < 200 || status > 599) return cleaned;
+	const entries = JSON.parse(await cleaned.text());
+	if (!isHeaderEntries(entries)) throw new Error("Invalid static-file request headers from the response stage");
+	return markEncodedStaticFileSignal(new Response(null, {
+		headers: cleaned.headers,
+		status
+	}), encodedPathname, new Headers(entries));
 }
 //#endregion
-export { createStaticFileSignal, isStaticFileSignal, readStaticFileSignal, restoreStaticFileSignalFromTransport, serializeStaticFileSignalForTransport };
+export { createStaticFileSignal, isStaticFileSignal, readStaticFileSignal, readStaticFileSignalRequestHeaders, restoreStaticFileSignalFromTransport, serializeStaticFileSignalForTransport };

package/dist/server/worker-image-optimization.d.ts

@@ -0,0 +1,34 @@
+import { VinextAssetFetcher } from "./multi-stage.js";
+import { ImageConfig, ImageOptimizationSignal } from "./image-optimization.js";
+//#region src/server/worker-image-optimization.d.ts
+export type WorkerImageSourceOptions = {
+  assets: VinextAssetFetcher;
+  basePath: string;
+  assetPathPrefix: string;
+  clientBuildFiles: ReadonlySet<string>;
+  /**
+   * Run `sourceRequest`, a GET without the caller's headers, through the
+   * application pipeline and return the public file it selects with a 2xx
+   * outcome, or null.
+   */
+  fetchPublicFile(sourceRequest: Request): Promise<Response | null>;
+};
+/**
+ * Fetch a local image source. Build output is fetched from the asset binding,
+ * which serves it before the Worker and its middleware. Any other source is
+ * served only when the application pipeline selects a public file for it.
+ */
+export declare function fetchWorkerImageSource(imageUrl: string, request: Request, options: WorkerImageSourceOptions): Promise<Response>;
+/**
+ * Return the public file a framework static-file signal selects, provided the
+ * pipeline answered with a body-bearing 2xx outcome. The file is fetched with middleware's
+ * request header overrides, as resolveStaticAssetSignal fetches it.
+ */
+export declare function fetchSignalledPublicFile(response: Response, sourceRequest: Request, assets: VinextAssetFetcher): Promise<Response> | null;
+/**
+ * Serve the App Router image endpoint once the request handler admitted it
+ * through middleware and rewrites. Middleware's response headers are sent with
+ * the image, as Next.js does.
+ */
+export declare function serveWorkerImageOptimization(request: Request, signal: ImageOptimizationSignal, allowedWidths: number[] | undefined, imageConfig: ImageConfig | undefined, options: WorkerImageSourceOptions): Promise<Response>;
+//#endregion

package/dist/server/worker-image-optimization.js

@@ -0,0 +1,86 @@
+import { isNextStaticPath } from "../utils/asset-prefix.js";
+import { normalizePathnameForRouteMatchStrict } from "../routing/utils.js";
+import { VINEXT_PRERENDER_SPECIAL_ERROR_HEADER } from "./headers.js";
+import { normalizePath } from "./normalize-path.js";
+import { readStaticFileSignal, readStaticFileSignalRequestHeaders } from "./static-file-signal.js";
+import { attachRequestCfMetadata, cloneRequestWithUrl } from "./request-pipeline.js";
+import { handleConfiguredImageOptimization, invalidImageSourceResponse, isImageSourceBodyStatus } from "./image-optimization.js";
+import { createStaticAssetRequest, mergeHeaders } from "./worker-utils.js";
+import { resolveClientBuildFile } from "./client-build-files.js";
+//#region src/server/worker-image-optimization.ts
+/**
+* Image optimization for Worker hosts. A local source is fetched as an
+* anonymous direct request would receive it, like Next.js' fetchInternalImage
+* (packages/next/src/server/image-optimizer.ts), so middleware that denies or
+* redirects a direct request also denies the optimizer.
+*/
+const OMITTED_MIDDLEWARE_HEADERS = /* @__PURE__ */ new Set([
+	"content-encoding",
+	"content-length",
+	"content-range",
+	"content-type",
+	"transfer-encoding",
+	VINEXT_PRERENDER_SPECIAL_ERROR_HEADER
+]);
+function cancelResponseBody(response) {
+	const body = response.body;
+	if (!body || body.locked) return;
+	body.cancel().catch(() => {});
+}
+/**
+* Fetch a local image source. Build output is fetched from the asset binding,
+* which serves it before the Worker and its middleware. Any other source is
+* served only when the application pipeline selects a public file for it.
+*/
+async function fetchWorkerImageSource(imageUrl, request, options) {
+	const sourceUrl = new URL(imageUrl, request.url);
+	let sourcePathname;
+	try {
+		sourcePathname = normalizePath(normalizePathnameForRouteMatchStrict(sourceUrl.pathname));
+	} catch {
+		return invalidImageSourceResponse();
+	}
+	const buildAssetPath = isNextStaticPath(sourcePathname, options.basePath, options.assetPathPrefix) ? sourcePathname : resolveClientBuildFile(sourceUrl.pathname, options.basePath, options.clientBuildFiles);
+	if (buildAssetPath !== null) return options.assets.fetch(new Request(new URL(buildAssetPath, request.url)));
+	const sourceResponse = await options.fetchPublicFile(attachRequestCfMetadata(new Request(sourceUrl, { signal: request.signal }), request));
+	if (sourceResponse && isImageSourceBodyStatus(sourceResponse.status)) return sourceResponse;
+	if (sourceResponse) cancelResponseBody(sourceResponse);
+	return invalidImageSourceResponse();
+}
+/**
+* Return the public file a framework static-file signal selects, provided the
+* pipeline answered with a body-bearing 2xx outcome. The file is fetched with middleware's
+* request header overrides, as resolveStaticAssetSignal fetches it.
+*/
+function fetchSignalledPublicFile(response, sourceRequest, assets) {
+	const signal = isImageSourceBodyStatus(response.status) ? readStaticFileSignal(response) : null;
+	const requestHeaders = readStaticFileSignalRequestHeaders(response);
+	cancelResponseBody(response);
+	if (signal === null) return null;
+	let assetPath = signal;
+	try {
+		assetPath = decodeURIComponent(signal);
+	} catch {}
+	return Promise.resolve(assets.fetch(createStaticAssetRequest(assetPath, sourceRequest, requestHeaders)));
+}
+/**
+* Serve the App Router image endpoint once the request handler admitted it
+* through middleware and rewrites. Middleware's response headers are sent with
+* the image, as Next.js does.
+*/
+async function serveWorkerImageOptimization(request, signal, allowedWidths, imageConfig, options) {
+	const imageUrl = new URL(request.url);
+	imageUrl.search = signal.search;
+	const imageRequest = cloneRequestWithUrl(request, imageUrl.href);
+	const response = await handleConfiguredImageOptimization(signal.requestHeaders ? new Request(imageRequest, { headers: signal.requestHeaders }) : imageRequest, (sourceUrl) => fetchWorkerImageSource(sourceUrl, imageRequest, options), allowedWidths, imageConfig);
+	const middlewareHeaders = {};
+	signal.middlewareHeaders.forEach((value, name) => {
+		if (name === "set-cookie" || OMITTED_MIDDLEWARE_HEADERS.has(name)) return;
+		middlewareHeaders[name] = value;
+	});
+	const cookies = signal.middlewareHeaders.getSetCookie();
+	if (cookies.length > 0) middlewareHeaders["set-cookie"] = cookies;
+	return mergeHeaders(response, middlewareHeaders);
+}
+//#endregion
+export { fetchSignalledPublicFile, fetchWorkerImageSource, serveWorkerImageOptimization };

package/dist/server/worker-stages.d.ts

@@ -1,7 +1,7 @@
 import { VinextResponseStageCacheability, VinextResponseStageTransport } from "./multi-stage.js";
 import { PagesRenderOptions } from "./pages-request-pipeline.js";
 //#region src/server/worker-stages.d.ts
-export declare const PAGES_RESPONSE_STAGE_PROTOCOL_VERSION = 4;
+export declare const PAGES_RESPONSE_STAGE_PROTOCOL_VERSION = 5;
 export declare const PAGES_RESPONSE_STAGE_POLICY_OWNER_HEADER = "x-vinext-pages-response-stage-policy-owner";
 export type PagesResponseStagePolicyOwner = "request-time" | "static";
 type PagesResponseStageEnvelope = {

package/dist/server/worker-stages.js

@@ -1,5 +1,5 @@
 //#region src/server/worker-stages.ts
-const PAGES_RESPONSE_STAGE_PROTOCOL_VERSION = 4;
+const PAGES_RESPONSE_STAGE_PROTOCOL_VERSION = 5;
 const PAGES_RESPONSE_STAGE_POLICY_OWNER_HEADER = "x-vinext-pages-response-stage-policy-owner";
 function isSerializedHeaders(value) {
 	return Array.isArray(value) && value.every((entry) => Array.isArray(entry) && entry.length === 2 && typeof entry[0] === "string" && typeof entry[1] === "string");
@@ -12,7 +12,7 @@ function isResponseStageCacheability(value) {
 function isPagesResponseStageProps(value) {
 	if (!value || typeof value !== "object") return false;
 	const props = value;
-	if (props.protocolVersion !== 4 || props.buildId !== null && typeof props.buildId !== "string" || !isResponseStageCacheability(props.cacheability) || typeof props.requestHost !== "string" || props.requestHost.length === 0 || props.stagedHeaders !== null && !isSerializedHeaders(props.stagedHeaders)) return false;
+	if (props.protocolVersion !== 5 || props.buildId !== null && typeof props.buildId !== "string" || !isResponseStageCacheability(props.cacheability) || typeof props.requestHost !== "string" || props.requestHost.length === 0 || props.stagedHeaders !== null && !isSerializedHeaders(props.stagedHeaders)) return false;
 	if (props.kind === "pages-api") return typeof props.apiUrl === "string";
 	if (props.kind === "pages-prerender-discovery") return true;
 	if (props.kind !== "pages-page" || typeof props.resolvedUrl !== "string") return false;

package/dist/server/worker-utils.d.ts

@@ -2,8 +2,13 @@
 export declare function finalizeMissingStaticAssetResponse(response: Response, missingBuildAsset: boolean): Response;
 export declare function mergeHeaders(response: Response, extraHeaders: Record<string, string | string[]>, statusOverride?: number): Response;
 export declare function resolveStaticAssetSignal(signalResponse: Response, options: {
-  fetchAsset(path: string): Promise<Response>;
+  /** `requestHeaders` are the post-middleware request headers, when middleware set any. */
+  fetchAsset(path: string, requestHeaders: Headers | null): Promise<Response>;
 }): Promise<Response | null>;
-/** Retarget a Worker asset request without dropping its conditional/range fields. */
-export declare function createStaticAssetRequest(assetPath: string, sourceRequest: Request): Request;
+/**
+ * Retarget a Worker asset request without dropping its conditional/range
+ * fields. `headers` replaces the source request's headers with middleware's
+ * overrides, so a removed `Range` or replaced validator reaches the asset fetch.
+ */
+export declare function createStaticAssetRequest(assetPath: string, sourceRequest: Request, headers?: Headers | null): Request;
 //#endregion

package/dist/server/worker-utils.js

@@ -1,5 +1,5 @@
 import { notFoundStaticAssetResponse } from "./http-error-responses.js";
-import { readStaticFileSignal } from "./static-file-signal.js";
+import { readStaticFileSignal, readStaticFileSignalRequestHeaders } from "./static-file-signal.js";
 //#region src/server/worker-utils.ts
 /**
 * Shared utilities for Cloudflare Worker entries.
@@ -47,7 +47,7 @@ function buildHeaderRecord(response, omitNames = []) {
 	return headers;
 }
 function mergeHeaders(response, extraHeaders, statusOverride) {
-	const status = statusOverride ?? response.status;
+	const status = response.status === 304 ? 304 : statusOverride ?? response.status;
 	const merged = new Headers();
 	for (const [k, v] of Object.entries(extraHeaders)) {
 		if (isContentLengthHeader(k)) continue;
@@ -97,17 +97,22 @@ async function resolveStaticAssetSignal(signalResponse, options) {
 		"content-type",
 		"transfer-encoding"
 	]);
+	const requestHeaders = readStaticFileSignalRequestHeaders(signalResponse);
 	cancelResponseBody(signalResponse);
-	const assetResponse = await options.fetchAsset(assetPath);
+	const assetResponse = await options.fetchAsset(assetPath, requestHeaders);
 	return mergeHeaders(assetResponse, extraHeaders, assetResponse.ok && assetResponse.status !== 206 && signalResponse.status !== 200 ? signalResponse.status : void 0);
 }
-/** Retarget a Worker asset request without dropping its conditional/range fields. */
-function createStaticAssetRequest(assetPath, sourceRequest) {
+/**
+* Retarget a Worker asset request without dropping its conditional/range
+* fields. `headers` replaces the source request's headers with middleware's
+* overrides, so a removed `Range` or replaced validator reaches the asset fetch.
+*/
+function createStaticAssetRequest(assetPath, sourceRequest, headers = null) {
 	const assetUrl = new URL(assetPath, sourceRequest.url);
-	if (sourceRequest.method === "GET" || sourceRequest.method === "HEAD") return new Request(assetUrl, sourceRequest);
+	if (sourceRequest.method === "GET" || sourceRequest.method === "HEAD") return headers ? new Request(new Request(assetUrl, sourceRequest), { headers }) : new Request(assetUrl, sourceRequest);
 	return new Request(assetUrl, {
 		method: sourceRequest.method,
-		headers: sourceRequest.headers
+		headers: headers ?? sourceRequest.headers
 	});
 }
 //#endregion

package/dist/shims/app-router-scroll.js

@@ -1,4 +1,5 @@
 "use client";
+import { disableSmoothScrollDuringRouteTransition } from "./disable-smooth-scroll.js";
 import { decodeHashFragment } from "./hash-scroll.js";
 import { consumeAppRouterScrollIntent, getPendingAppRouterScrollIntent, markAppRouterScrollIntentHeadHoisted } from "./app-router-scroll-state.js";
 import * as React$1 from "react";
@@ -110,7 +111,9 @@ var AppRouterScrollTargetInner = class extends React$1.Component {
 		const target = next.element;
 		const consumed = consumeAppRouterScrollIntent(intent, this.props.commitId);
 		if (consumed === null) return;
-		scrollToElement(target, consumed.hash);
+		disableSmoothScrollDuringRouteTransition(() => {
+			scrollToElement(target, consumed.hash);
+		});
 		target.focus();
 	};
 	componentDidMount() {

package/dist/shims/app-router-tree-context.d.ts

@@ -0,0 +1,5 @@
+import React from "react";
+//#region src/shims/app-router-tree-context.d.ts
+export declare const AppRouterTreeContext: React.Context<boolean> | null;
+export declare function withAppRouterTree(children: React.ReactElement): React.ReactElement;
+//#endregion

package/dist/shims/app-router-tree-context.js

@@ -0,0 +1,27 @@
+import React from "react";
+//#region src/shims/app-router-tree-context.ts
+/**
+* Marks an App Router server render tree. The App Router SSR entry provides
+* `true` at its root; every other server tree (Pages Router pages,
+* `pages/_document`, ad-hoc react-dom/server renders) reads the `false`
+* default. Lets shared shims such as next/dynamic apply App Router semantics
+* only where Next.js does. In the browser, `window.next.appDir` (installed
+* when the App Router browser entry loads) identifies App Router documents.
+*
+* Stored on a global symbol so duplicate module instances share one context,
+* and null in react-server, which has no createContext (RSC is App Router
+* only).
+*/
+const APP_ROUTER_TREE_CONTEXT_KEY = Symbol.for("vinext.appRouterTreeContext");
+function getAppRouterTreeContext() {
+	if (typeof React.createContext !== "function") return null;
+	const globalState = globalThis;
+	globalState[APP_ROUTER_TREE_CONTEXT_KEY] ??= React.createContext(false);
+	return globalState[APP_ROUTER_TREE_CONTEXT_KEY];
+}
+const AppRouterTreeContext = getAppRouterTreeContext();
+function withAppRouterTree(children) {
+	return AppRouterTreeContext ? React.createElement(AppRouterTreeContext.Provider, { value: true }, children) : children;
+}
+//#endregion
+export { AppRouterTreeContext, withAppRouterTree };

package/dist/shims/cache-adapter-instantiate.d.ts

@@ -0,0 +1,50 @@
+//#region src/shims/cache-adapter-instantiate.d.ts
+/**
+ * Instantiate a declaratively configured cache adapter from its module's
+ * default export. The generated `virtual:vinext-cache-adapters` module calls
+ * this for both the `cache.data` and `cache.cdn` slots, so every router and
+ * runtime (Node.js dev/prod server and Cloudflare Workers) uses the same rule.
+ *
+ * Contract: the default export must be a function, and it receives one
+ * `{ env, options }` argument.
+ *
+ * - A `class` (class syntax, as Vite and every current toolchain emit it) is
+ *   invoked with `new`. It is recognised by the source text that
+ *   `Function.prototype.toString` must return for class syntax, which starts
+ *   with `class`, on a function that has [[Construct]].
+ * - Any other function is called as a factory, with plain-call semantics
+ *   (`this`, `new.target` and bound receivers are what a call gives them).
+ *   Existing factories therefore behave exactly as before, whatever their
+ *   `prototype` looks like (frozen, decorated, or inherited).
+ * - A constructor that is not class syntax (an ES5-compiled class, or a
+ *   bound or Proxy-wrapped class, whose source text is not observable) is
+ *   structurally indistinguishable from a factory without invoking it, so the
+ *   module states it explicitly by exporting a factory that constructs it:
+ *   `export default (args) => new Adapter(args)`.
+ *
+ * Classification never invokes the export, matches no error messages and
+ * never retries, so the export runs exactly once.
+ *
+ * The produced value must be an adapter (an object or a function, not a
+ * Promise) with the slot's required members; anything else throws an error
+ * naming what is wrong.
+ */
+export type CacheAdapterFactoryArgs = {
+  env: unknown;
+  options: unknown;
+};
+export type CacheAdapterSlot = "data" | "cdn";
+/**
+ * Whether `value` has a [[Construct]] internal method. A Proxy is
+ * constructible exactly when its target is; its no-op `construct` trap
+ * answers without running the export or reading any of its properties.
+ */
+export declare function isConstructor(value: unknown): boolean;
+/**
+ * Whether an export is class syntax and must be invoked with `new`. The
+ * [[Construct]] check excludes methods named `class`, whose source text
+ * also starts with that word.
+ */
+export declare function isClassExport(value: unknown): boolean;
+export declare function instantiateCacheAdapter<T>(exported: unknown, args: CacheAdapterFactoryArgs, slot: CacheAdapterSlot): T;
+//#endregion