vinext 1.1.0 → 1.2.0

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,11 +61,12 @@ 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;

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

@@ -43,5 +43,13 @@ export declare function isCancelledRequestBodyEnqueueError(err: unknown): boolea
  * 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

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,14 +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), benign static-asset `import()` rejections (see
-* `isBenignAssetImportError`) and Node's cancelled-request-body enqueue
-* race (see `isCancelledRequestBodyEnqueueError`), 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
@@ -67,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
@@ -82,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`.
@@ -179,8 +193,15 @@ function isCancelledRequestBodyEnqueueError(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;
@@ -206,6 +227,10 @@ function installSocketErrorBackstop() {
 			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) => {
@@ -216,6 +241,10 @@ function installSocketErrorBackstop() {
 			if (debug) console.warn(`[vinext] absorbed unhandledRejection ${code}`);
 			return;
 		}
+		if (proc[RUNNING_SERVER_FLAG]) {
+			console.error("[vinext] unhandledRejection:", reason);
+			return;
+		}
 		throw reason;
 	});
 }

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() {