vinext 0.1.1 → 0.1.2

package/dist/server/pages-asset-tags.js

@@ -1,4 +1,5 @@
 import { createNonceAttribute } from "./html.js";
+import { assetServingUrlFromBaseAnchored } from "../utils/manifest-paths.js";
 //#region src/server/pages-asset-tags.ts
 /**
 * Pages Router SSR asset-tag helpers.
@@ -33,18 +34,20 @@ function getManifestFilesForModule(manifest, moduleId) {
 	return null;
 }
 /**
-* Find the first `.js` file in the manifest for `moduleId` and return its
-* URL-path form (with a leading `/`). Used to resolve the hydration URL for
-* the matched page or the `_app` module.
+* Find the first `.js` file in the manifest for `moduleId` and return the URL it
+* is actually SERVED from. Used to resolve the client-navigation / hydration URL
+* for the matched page or the `_app` module (it is `import()`ed on the client),
+* so it must point at the served location: `assetPrefix` replaces `basePath` for
+* asset URLs. SSR-manifest values are base-anchored; re-anchor under any
+* configured `assetPrefix` (default `""` keeps the legacy `"/" + file`).
 */
-function resolveClientModuleUrl(manifest, moduleId) {
+function resolveClientModuleUrl(manifest, moduleId, basePath = "", assetPrefix = "") {
 	const files = getManifestFilesForModule(resolveSsrManifest(manifest), moduleId);
 	if (!files) return void 0;
 	for (let i = 0; i < files.length; i++) {
-		let file = files[i];
+		const file = files[i];
 		if (!file || !file.endsWith(".js")) continue;
-		if (file.charAt(0) !== "/") file = "/" + file;
-		return file;
+		return assetServingUrlFromBaseAnchored(file, basePath, assetPrefix);
 	}
 }
 /**
@@ -67,13 +70,16 @@ function collectAssetTags(options) {
 	const seen = /* @__PURE__ */ new Set();
 	const nonceAttr = createNonceAttribute(options.scriptNonce);
 	const deferAttr = options.disableOptimizedLoading ? "" : " defer";
+	const basePath = options.basePath ?? "";
+	const assetPrefix = options.assetPrefix ?? "";
+	const href = (value) => assetServingUrlFromBaseAnchored(value, basePath, assetPrefix);
 	const lazyChunks = typeof globalThis !== "undefined" && globalThis.__VINEXT_LAZY_CHUNKS__ || null;
 	const lazySet = lazyChunks && lazyChunks.length > 0 ? new Set(lazyChunks) : null;
 	if (typeof globalThis !== "undefined" && globalThis.__VINEXT_CLIENT_ENTRY__) {
 		const entry = globalThis.__VINEXT_CLIENT_ENTRY__;
 		seen.add(entry);
-		tags.push("<link rel=\"modulepreload\"" + nonceAttr + " href=\"/" + entry + "\" />");
-		tags.push("<script type=\"module\"" + deferAttr + nonceAttr + " src=\"/" + entry + "\" crossorigin><\/script>");
+		tags.push("<link rel=\"modulepreload\"" + nonceAttr + " href=\"" + href(entry) + "\" />");
+		tags.push("<script type=\"module\"" + deferAttr + nonceAttr + " src=\"" + href(entry) + "\" crossorigin><\/script>");
 	}
 	if (m) {
 		const allFiles = [];
@@ -102,11 +108,11 @@ function collectAssetTags(options) {
 			if (tf.charAt(0) === "/") tf = tf.slice(1);
 			if (seen.has(tf)) continue;
 			seen.add(tf);
-			if (tf.endsWith(".css")) tags.push("<link rel=\"stylesheet\"" + nonceAttr + " href=\"/" + tf + "\" />");
+			if (tf.endsWith(".css")) tags.push("<link rel=\"stylesheet\"" + nonceAttr + " href=\"" + href(tf) + "\" />");
 			else if (tf.endsWith(".js")) {
 				if (lazySet && lazySet.has(tf)) continue;
-				tags.push("<link rel=\"modulepreload\"" + nonceAttr + " href=\"/" + tf + "\" />");
-				tags.push("<script type=\"module\"" + deferAttr + nonceAttr + " src=\"/" + tf + "\" crossorigin><\/script>");
+				tags.push("<link rel=\"modulepreload\"" + nonceAttr + " href=\"" + href(tf) + "\" />");
+				tags.push("<script type=\"module\"" + deferAttr + nonceAttr + " src=\"" + href(tf) + "\" crossorigin><\/script>");
 			}
 		}
 	}

package/dist/server/pages-data-route.js

@@ -1,3 +1,4 @@
+import { NEXTJS_DEPLOYMENT_ID_HEADER } from "./headers.js";
 //#region src/server/pages-data-route.ts
 /**
 * Helpers for the Pages Router `/_next/data/{buildId}/{...page}.json` endpoint.
@@ -87,9 +88,12 @@ function buildNextDataJsonResponse(pageProps, safeJsonStringify, init) {
 * before checking the status code.
 */
 function buildNextDataNotFoundResponse() {
+	const headers = { "Content-Type": "application/json" };
+	const deploymentId = process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID;
+	if (deploymentId) headers[NEXTJS_DEPLOYMENT_ID_HEADER] = deploymentId;
 	return new Response("{}", {
 		status: 404,
-		headers: { "Content-Type": "application/json" }
+		headers
 	});
 }
 /**

package/dist/server/pages-node-compat.d.ts

@@ -1,34 +1,26 @@
 import { PagesBodyParseError } from "./pages-media-type.js";
 import { RevalidateOptions } from "./pages-revalidate.js";
+import { Readable, Writable } from "node:stream";
 
 //#region src/server/pages-node-compat.d.ts
 type PagesRequestQuery = Record<string, string | string[]>;
-type PagesReqResRequest = {
+type PagesReqResRequest = Readable & {
   method: string;
   url: string;
   headers: Record<string, string>;
   query: PagesRequestQuery;
   body: unknown;
   cookies: Record<string, string>;
-  /**
-   * Async-iterator hook so handlers can `for await (const chunk of req)` —
-   * matching Node's `IncomingMessage` contract. Critical for the
-   * `bodyParser: false` opt-out (webhook signature verification etc.) where
-   * `req.body` is left undefined and user code is expected to drain the raw
-   * stream off `req` itself.
-   */
-  [Symbol.asyncIterator]: () => AsyncIterator<Uint8Array>;
 };
 type PagesReqResHeaders = {
   [key: string]: string | number | boolean | string[];
 };
-type PagesReqResResponse = {
+type PagesReqResResponse = Writable & {
   statusCode: number;
   readonly headersSent: boolean;
   writeHead: (code: number, headers?: PagesReqResHeaders) => PagesReqResResponse;
   setHeader: (name: string, value: string | number | boolean | string[]) => PagesReqResResponse;
   getHeader: (name: string) => string | number | boolean | string[] | undefined;
-  end: (data?: BodyInit | null) => void;
   status: (code: number) => PagesReqResResponse;
   json: (data: unknown) => void;
   send: (data: unknown) => void;

package/dist/server/pages-node-compat.js

@@ -4,6 +4,7 @@ import { PagesBodyParseError, getMediaType, isJsonMediaType } from "./pages-medi
 import { DEFAULT_PAGES_API_BODY_SIZE_LIMIT } from "./pages-body-parser-config.js";
 import { performOnDemandRevalidate } from "./pages-revalidate.js";
 import { decode } from "node:querystring";
+import { Readable, Writable } from "node:stream";
 //#region src/server/pages-node-compat.ts
 const MAX_PAGES_API_BODY_SIZE = DEFAULT_PAGES_API_BODY_SIZE_LIMIT;
 async function readPagesRequestBodyWithLimit(request, maxBytes) {
@@ -41,140 +42,192 @@ async function parsePagesApiBody(request, maxBytes = MAX_PAGES_API_BODY_SIZE) {
 	if (mediaType === "application/x-www-form-urlencoded") return decode(rawBody);
 	return rawBody;
 }
+async function* requestBodyChunks(request) {
+	if (!request.body || request.bodyUsed) return;
+	const reader = request.body.getReader();
+	try {
+		for (;;) {
+			const { value, done } = await reader.read();
+			if (done) return;
+			yield Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+		}
+	} finally {
+		try {
+			await reader.cancel();
+		} catch {}
+		reader.releaseLock();
+	}
+}
+function createRequestReadable(request) {
+	return Readable.from(requestBodyChunks(request), { objectMode: false });
+}
+var PagesResponseStream = class extends Writable {
+	resolveResponse;
+	rejectResponse;
+	requestHeaders;
+	resStatusCode = 200;
+	resHeaders = {};
+	setCookieHeaders = [];
+	resolved = false;
+	controller = null;
+	bufferedChunks = [];
+	streamEnded = false;
+	constructor(resolveResponse, rejectResponse, requestHeaders) {
+		super();
+		this.resolveResponse = resolveResponse;
+		this.rejectResponse = rejectResponse;
+		this.requestHeaders = requestHeaders;
+		this.once("error", (err) => {
+			if (!this.resolved) {
+				this.resolved = true;
+				this.rejectResponse(err);
+			}
+		});
+	}
+	get statusCode() {
+		return this.resStatusCode;
+	}
+	set statusCode(code) {
+		this.resStatusCode = code;
+	}
+	get headersSent() {
+		return this.writableEnded || this.resolved;
+	}
+	writeHead(code, headers) {
+		this.resStatusCode = code;
+		if (headers) for (const [key, value] of Object.entries(headers)) this.setHeaderValue(key, value, { replaceSetCookie: false });
+		return this;
+	}
+	setHeader(name, value) {
+		this.setHeaderValue(name, value, { replaceSetCookie: true });
+		return this;
+	}
+	getHeader(name) {
+		if (name.toLowerCase() === "set-cookie") return this.setCookieHeaders.length > 0 ? this.setCookieHeaders : void 0;
+		return this.resHeaders[name.toLowerCase()];
+	}
+	status(code) {
+		this.resStatusCode = code;
+		return this;
+	}
+	json(data) {
+		this.resHeaders["content-type"] = "application/json";
+		this.end(JSON.stringify(data));
+	}
+	send(data) {
+		if (Buffer.isBuffer(data)) {
+			if (!this.resHeaders["content-type"]) this.resHeaders["content-type"] = "application/octet-stream";
+			this.resHeaders["content-length"] = String(data.length);
+			this.end(data);
+			return;
+		}
+		if (typeof data === "object" && data !== null) {
+			this.resHeaders["content-type"] = "application/json";
+			this.end(JSON.stringify(data));
+			return;
+		}
+		if (!this.resHeaders["content-type"]) this.resHeaders["content-type"] = "text/plain";
+		this.end(String(data));
+	}
+	redirect(statusOrUrl, url) {
+		if (typeof statusOrUrl === "string") this.writeHead(307, { Location: statusOrUrl });
+		else this.writeHead(statusOrUrl, { Location: url ?? "" });
+		this.end();
+	}
+	getHeaders() {
+		const headers = { ...this.resHeaders };
+		if (this.setCookieHeaders.length > 0) headers["set-cookie"] = this.setCookieHeaders;
+		return headers;
+	}
+	async revalidate(urlPath, opts) {
+		await performOnDemandRevalidate(this.requestHeaders, urlPath, opts);
+	}
+	_write(chunk, encoding, callback) {
+		const buffer = typeof chunk === "string" ? Buffer.from(chunk, encoding) : Buffer.from(chunk);
+		if (this.controller && !this.streamEnded) try {
+			this.controller.enqueue(buffer);
+		} catch {}
+		else this.bufferedChunks.push(buffer);
+		this.resolveOnce();
+		callback();
+	}
+	_final(callback) {
+		this.streamEnded = true;
+		if (this.controller) try {
+			this.controller.close();
+		} catch {}
+		this.resolveOnce();
+		callback();
+	}
+	_destroy(error, callback) {
+		this.streamEnded = true;
+		if (!this.resolved) if (error) {
+			this.resolved = true;
+			this.rejectResponse(error);
+		} else this.resolveOnce();
+		if (this.controller) try {
+			if (error) this.controller.error(error);
+			else this.controller.close();
+		} catch {}
+		callback(error);
+	}
+	setHeaderValue(name, value, options) {
+		if (name.toLowerCase() === "set-cookie") {
+			if (options.replaceSetCookie) this.setCookieHeaders.length = 0;
+			if (Array.isArray(value)) this.setCookieHeaders.push(...value.map(String));
+			else this.setCookieHeaders.push(String(value));
+			return;
+		}
+		this.resHeaders[name.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+	}
+	resolveOnce() {
+		if (this.resolved) return;
+		this.resolved = true;
+		const headers = new Headers();
+		for (const [key, value] of Object.entries(this.resHeaders)) headers.set(key, String(value));
+		for (const cookie of this.setCookieHeaders) headers.append("set-cookie", cookie);
+		const stream = new ReadableStream({
+			start: (controller) => {
+				this.controller = controller;
+				for (const buffer of this.bufferedChunks) try {
+					controller.enqueue(buffer);
+				} catch {}
+				this.bufferedChunks.length = 0;
+				if (this.streamEnded) try {
+					controller.close();
+				} catch {}
+			},
+			cancel: (reason) => {
+				this.bufferedChunks.length = 0;
+				this.destroy(reason instanceof Error ? reason : /* @__PURE__ */ new Error("Response body cancelled"));
+			}
+		});
+		this.resolveResponse(new Response(stream, {
+			status: this.resStatusCode,
+			headers
+		}));
+	}
+};
 function createPagesReqRes(options) {
 	const headersObj = {};
 	for (const [key, value] of options.request.headers) headersObj[key.toLowerCase()] = value;
-	const requestBody = options.request.body;
-	const reqAsyncIterator = () => {
-		if (!requestBody) return { next() {
-			return Promise.resolve({
-				value: void 0,
-				done: true
-			});
-		} };
-		const reader = requestBody.getReader();
-		return {
-			async next() {
-				const { value, done } = await reader.read();
-				if (done) return {
-					value: void 0,
-					done: true
-				};
-				return {
-					value,
-					done: false
-				};
-			},
-			async return() {
-				try {
-					await reader.cancel();
-				} catch {}
-				return {
-					value: void 0,
-					done: true
-				};
-			}
-		};
-	};
-	const req = {
+	const req = Object.assign(createRequestReadable(options.request), {
 		method: options.request.method,
 		url: options.url,
 		headers: headersObj,
 		query: options.query,
 		body: options.body,
-		cookies: parseCookies(options.request.headers.get("cookie")),
-		[Symbol.asyncIterator]: reqAsyncIterator
-	};
-	let resStatusCode = 200;
-	const resHeaders = {};
-	const setCookieHeaders = [];
-	let resBody = null;
-	let ended = false;
+		cookies: parseCookies(options.request.headers.get("cookie"))
+	});
 	let resolveResponse;
-	const responsePromise = new Promise((resolve) => {
+	let rejectResponse;
+	const responsePromise = new Promise((resolve, reject) => {
 		resolveResponse = resolve;
+		rejectResponse = reject;
 	});
-	const res = {
-		get statusCode() {
-			return resStatusCode;
-		},
-		set statusCode(code) {
-			resStatusCode = code;
-		},
-		get headersSent() {
-			return ended;
-		},
-		writeHead(code, headers) {
-			resStatusCode = code;
-			if (headers) for (const [key, value] of Object.entries(headers)) if (key.toLowerCase() === "set-cookie") if (Array.isArray(value)) setCookieHeaders.push(...value.map(String));
-			else setCookieHeaders.push(String(value));
-			else resHeaders[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
-			return res;
-		},
-		setHeader(name, value) {
-			if (name.toLowerCase() === "set-cookie") {
-				setCookieHeaders.length = 0;
-				if (Array.isArray(value)) setCookieHeaders.push(...value.map(String));
-				else setCookieHeaders.push(String(value));
-			} else resHeaders[name.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
-			return res;
-		},
-		getHeader(name) {
-			if (name.toLowerCase() === "set-cookie") return setCookieHeaders.length > 0 ? setCookieHeaders : void 0;
-			return resHeaders[name.toLowerCase()];
-		},
-		end(data) {
-			if (ended) return;
-			ended = true;
-			if (data !== void 0 && data !== null) resBody = data;
-			const headers = new Headers();
-			for (const [key, value] of Object.entries(resHeaders)) headers.set(key, String(value));
-			for (const cookie of setCookieHeaders) headers.append("set-cookie", cookie);
-			resolveResponse(new Response(resBody, {
-				status: resStatusCode,
-				headers
-			}));
-		},
-		status(code) {
-			resStatusCode = code;
-			return res;
-		},
-		json(data) {
-			resHeaders["content-type"] = "application/json";
-			res.end(JSON.stringify(data));
-		},
-		send(data) {
-			if (Buffer.isBuffer(data)) {
-				if (!resHeaders["content-type"]) resHeaders["content-type"] = "application/octet-stream";
-				resHeaders["content-length"] = String(data.length);
-				res.end(new Uint8Array(data));
-				return;
-			}
-			if (typeof data === "object" && data !== null) {
-				resHeaders["content-type"] = "application/json";
-				res.end(JSON.stringify(data));
-				return;
-			}
-			if (!resHeaders["content-type"]) resHeaders["content-type"] = "text/plain";
-			res.end(String(data));
-		},
-		redirect(statusOrUrl, url) {
-			if (typeof statusOrUrl === "string") res.writeHead(307, { Location: statusOrUrl });
-			else res.writeHead(statusOrUrl, { Location: url ?? "" });
-			res.end();
-		},
-		getHeaders() {
-			const headers = { ...resHeaders };
-			if (setCookieHeaders.length > 0) headers["set-cookie"] = setCookieHeaders;
-			return headers;
-		},
-		async revalidate(urlPath, opts) {
-			await performOnDemandRevalidate(options.request.headers, urlPath, opts);
-		}
-	};
 	return {
 		req,
-		res,
+		res: new PagesResponseStream(resolveResponse, rejectResponse, options.request.headers),
 		responsePromise
 	};
 }

package/dist/server/pages-page-data.d.ts

@@ -138,6 +138,13 @@ type ResolvePagesPageDataOptions = {
    * presence — see the security note in `isr-cache.ts`.
    */
   isOnDemandRevalidate?: boolean;
+  /**
+   * The deployment ID used for deployment-skew protection. When set, it is
+   * included as `x-nextjs-deployment-id` on all `_next/data` responses
+   * (success, redirect, notFound). Mirrors Next.js pages-handler.ts behavior.
+   * Typically sourced from `process.env.__VINEXT_DEPLOYMENT_ID || process.env.NEXT_DEPLOYMENT_ID`.
+   */
+  deploymentId?: string;
   pageModule: PagesPageModule;
   params: Record<string, unknown>;
   query: Record<string, unknown>;
@@ -158,6 +165,27 @@ type ResolvePagesPageDataOptions = {
   renderIsrPassToStringAsync: (element: ReactNode) => Promise<string>;
   vinext?: VinextNextData["__vinext"];
   nextData?: PagesNextDataExtras;
+  /**
+   * The request's User-Agent string. When this matches a known crawler/bot
+   * pattern, ISR cache-HIT and cache-STALE responses receive an ETag header
+   * for consistency with the fresh-MISS path (which also attaches an ETag for
+   * bot UAs via `renderPagesPageResponse`). See the divergence note in
+   * `pages-page-response.ts` for why UA-gating is used instead of Next.js's
+   * `isDynamic` check.
+   */
+  userAgent?: string;
+  /**
+   * The incoming request's `If-None-Match` header value. When the cached HTML
+   * ETag matches (weak-ETag semantics), the ISR cache-HIT or cache-STALE
+   * response is a `304 Not Modified` with no body.
+   */
+  ifNoneMatch?: string;
+  /**
+   * The incoming request's `Cache-Control` header value. When it contains
+   * `no-cache`, the 304 short-circuit is skipped and a full response is
+   * returned — mirroring the `fresh` package used by Next.js.
+   */
+  requestCacheControl?: string;
 };
 type ResolvePagesPageDataRenderResult = {
   kind: "render";

package/dist/server/pages-page-data.js

@@ -1,22 +1,26 @@
+import { NEXTJS_DEPLOYMENT_ID_HEADER } from "./headers.js";
 import { normalizeStaticPathname } from "../routing/route-pattern.js";
 import { buildCacheStateHeaders } from "./cache-headers.js";
+import { applyCdnResponseHeaders } from "./cache-control.js";
+import { decideIsr } from "./isr-decision.js";
 import { buildPagesCacheValue } from "./isr-cache.js";
 import { isSerializableProps } from "./pages-serializable-props.js";
 import { hasPagesGetInitialProps, isResponseSent, loadPagesGetInitialProps } from "./pages-get-initial-props.js";
-import { applyCdnResponseHeaders, buildCachedRevalidateCacheControl } from "./cache-control.js";
 import { buildNextDataJsonResponse } from "./pages-data-route.js";
-import { buildPagesNextDataScript } from "./pages-page-response.js";
+import { buildPagesNextDataScript, etagMatches, generatePagesETag, isPagesStreamingBot, requestsNoCache } from "./pages-page-response.js";
 //#region src/server/pages-page-data.ts
-function buildPagesDataNotFoundResponse() {
+function buildPagesDataNotFoundResponse(deploymentId) {
+	const headers = { "Content-Type": "application/json" };
+	if (deploymentId) headers[NEXTJS_DEPLOYMENT_ID_HEADER] = deploymentId;
 	return new Response("{}", {
 		status: 404,
-		headers: { "Content-Type": "application/json" }
+		headers
 	});
 }
 function buildPagesNotFoundResult(options) {
 	if (options.isDataReq) return {
 		kind: "response",
-		response: buildPagesDataNotFoundResponse()
+		response: buildPagesDataNotFoundResponse(options.deploymentId)
 	};
 	return { kind: "notFound" };
 }
@@ -46,10 +50,14 @@ function resolvePagesRedirectStatus(redirect) {
 */
 function buildPagesRedirectResponse(redirect, options) {
 	const destination = options.sanitizeDestination(redirect.destination);
-	if (options.isDataReq) return buildNextDataJsonResponse({
-		__N_REDIRECT: destination,
-		__N_REDIRECT_STATUS: resolvePagesRedirectStatus(redirect)
-	}, options.safeJsonStringify);
+	if (options.isDataReq) {
+		const init = { headers: {} };
+		if (options.deploymentId) init.headers[NEXTJS_DEPLOYMENT_ID_HEADER] = options.deploymentId;
+		return buildNextDataJsonResponse({
+			__N_REDIRECT: destination,
+			__N_REDIRECT_STATUS: resolvePagesRedirectStatus(redirect)
+		}, options.safeJsonStringify, init);
+	}
 	return new Response(null, {
 		status: resolvePagesRedirectStatus(redirect),
 		headers: { Location: destination }
@@ -81,19 +89,47 @@ function matchesPagesStaticPath(pathEntry, params, routeUrl) {
 	});
 }
 function buildPagesCacheResponse(html, cacheState, fontLinkHeader, revalidateSeconds, expireSeconds, cacheControl, status) {
-	const effectiveRevalidateSeconds = cacheControl?.revalidate ?? revalidateSeconds ?? 60;
-	const effectiveExpireSeconds = cacheControl === void 0 ? void 0 : cacheControl.expire ?? expireSeconds;
+	const { cacheControl: cacheControlHeader } = decideIsr({
+		cacheState,
+		kind: "pages",
+		revalidateSeconds: revalidateSeconds ?? 60,
+		expireSeconds,
+		cacheControlMeta: cacheControl
+	});
 	const headers = new Headers({
 		"Content-Type": "text/html",
 		...buildCacheStateHeaders(cacheState)
 	});
-	applyCdnResponseHeaders(headers, { cacheControl: buildCachedRevalidateCacheControl(cacheState, effectiveRevalidateSeconds, effectiveExpireSeconds) });
+	applyCdnResponseHeaders(headers, { cacheControl: cacheControlHeader });
 	if (fontLinkHeader) headers.set("Link", fontLinkHeader);
 	return new Response(html, {
 		status: status ?? 200,
 		headers
 	});
 }
+/**
+* For bot / crawler UAs, attach an ETag to a cached ISR response (HIT or
+* STALE) so it is consistent with the fresh-MISS path, then check for a
+* matching `If-None-Match`. When the check passes — and the request did NOT
+* carry `Cache-Control: no-cache` — returns a 304 response; otherwise returns
+* `null` so the caller can return the full response.
+*
+* Extracted to avoid duplicating the same three-line block across the HIT and
+* STALE branches.
+*/
+function applyBotETagAndCheck(cachedResponse, html, options) {
+	if (!options.userAgent || !isPagesStreamingBot(options.userAgent)) return null;
+	const etag = generatePagesETag(html);
+	cachedResponse.headers.set("ETag", etag);
+	if (!requestsNoCache(options.requestCacheControl) && options.ifNoneMatch && etagMatches(etag, options.ifNoneMatch)) return {
+		kind: "response",
+		response: new Response(null, {
+			status: 304,
+			headers: cachedResponse.headers
+		})
+	};
+	return null;
+}
 function rewritePagesCachedHtml(cachedHtml, freshBody, nextDataScript) {
 	const bodyStart = cachedHtml.indexOf("<div id=\"__next\">");
 	const contentStart = bodyStart >= 0 ? bodyStart + 17 : -1;
@@ -175,10 +211,15 @@ async function resolvePagesPageData(options) {
 		const cacheKey = options.isrCacheKey("pages", pathname);
 		const cached = await options.isrGet(cacheKey);
 		const cachedValue = cached?.value.value;
-		if (!options.isOnDemandRevalidate && cachedValue?.kind === "PAGES" && cached && !cached.isStale && !options.scriptNonce && !options.isDataReq) return {
-			kind: "response",
-			response: buildPagesCacheResponse(cachedValue.html, "HIT", options.fontLinkHeader, void 0, options.expireSeconds, cached.value.cacheControl, cachedValue.status)
-		};
+		if (!options.isOnDemandRevalidate && cachedValue?.kind === "PAGES" && cached && !cached.isStale && !options.scriptNonce && !options.isDataReq) {
+			const hitResponse = buildPagesCacheResponse(cachedValue.html, "HIT", options.fontLinkHeader, void 0, options.expireSeconds, cached.value.cacheControl, cachedValue.status);
+			const hitBotResult = applyBotETagAndCheck(hitResponse, cachedValue.html, options);
+			if (hitBotResult) return hitBotResult;
+			return {
+				kind: "response",
+				response: hitResponse
+			};
+		}
 		if (!options.isOnDemandRevalidate && cachedValue?.kind === "PAGES" && cached && cached.isStale && !options.scriptNonce && !options.isDataReq) {
 			options.triggerBackgroundRegeneration(cacheKey, async function() {
 				return options.runInFreshUnifiedContext(async () => {
@@ -212,9 +253,12 @@ async function resolvePagesPageData(options) {
 				routePath: options.routePattern,
 				routeType: "render"
 			});
+			const staleResponse = buildPagesCacheResponse(cachedValue.html, "STALE", options.fontLinkHeader, void 0, options.expireSeconds, cached.value.cacheControl, cachedValue.status);
+			const staleBotResult = applyBotETagAndCheck(staleResponse, cachedValue.html, options);
+			if (staleBotResult) return staleBotResult;
 			return {
 				kind: "response",
-				response: buildPagesCacheResponse(cachedValue.html, "STALE", options.fontLinkHeader, void 0, options.expireSeconds, cached.value.cacheControl, cachedValue.status)
+				response: staleResponse
 			};
 		}
 		const result = await options.pageModule.getStaticProps({

package/dist/server/pages-page-handler.d.ts

@@ -28,6 +28,7 @@ type I18nConfig = {
 } | null;
 type VinextConfigSubset = {
   basePath: string;
+  assetPrefix: string;
   trailingSlash: boolean;
   expireTime?: number;
   clientTraceMetadata?: readonly string[];