vinext 0.1.4 → 0.1.6

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

@@ -1,10 +1,10 @@
 import { getRequestExecutionContext } from "../shims/request-context.js";
 import { reportRequestError } from "./instrumentation.js";
 import { setCacheStateHeaders } from "./cache-headers.js";
-import { fnv1a52 } from "../utils/hash.js";
-import { encodeCacheTag } from "../utils/encode-cache-tag.js";
 import { NEVER_CACHE_CONTROL, NO_STORE_CACHE_CONTROL, applyCdnResponseHeaders } from "./cache-control.js";
 import { buildMissIsrCacheControl } from "./isr-decision.js";
+import { fnv1a52 } from "../utils/hash.js";
+import { encodeCacheTag } from "../utils/encode-cache-tag.js";
 import { appendAssetDeploymentIdQuery } from "../utils/deployment-id.js";
 import { withScriptNonce } from "../shims/script-nonce-context.js";
 import { createNonceAttribute, escapeHtmlAttr } from "./html.js";

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

@@ -106,7 +106,9 @@ type PagesPipelineResult = {
  * ASSUMPTION: request already has internal headers filtered and basePath stripped.
  * The adapter is responsible for that pre-processing before calling runPagesRequest.
  * The adapter also handles: open-redirect guard, _next/static 404, image optimization,
- * _next/data normalization, Node decode/normalize/400, public-file serving.
+ * _next/data normalization and classification: adapters must rewrite the data
+ * URL to its page pathname and set `isDataReq` (the source of truth here), Node
+ * decode/normalize/400, public-file serving.
  * runPagesRequest receives a "clean" request with basePath-stripped URL.
  */
 declare function runPagesRequest(request: Request, deps: PagesPipelineDeps): Promise<PagesPipelineResult>;

package/dist/server/pages-request-pipeline.js

@@ -40,7 +40,9 @@ function wrapMiddlewareWithBasePath(runMiddleware, basePath, hadBasePath) {
 * ASSUMPTION: request already has internal headers filtered and basePath stripped.
 * The adapter is responsible for that pre-processing before calling runPagesRequest.
 * The adapter also handles: open-redirect guard, _next/static 404, image optimization,
-* _next/data normalization, Node decode/normalize/400, public-file serving.
+* _next/data normalization and classification: adapters must rewrite the data
+* URL to its page pathname and set `isDataReq` (the source of truth here), Node
+* decode/normalize/400, public-file serving.
 * runPagesRequest receives a "clean" request with basePath-stripped URL.
 */
 async function runPagesRequest(request, deps) {
@@ -54,7 +56,7 @@ async function runPagesRequest(request, deps) {
 		hadBasePath
 	};
 	{
-		const trailingSlashRedirect = normalizeTrailingSlash(pathname, basePath, trailingSlash, search);
+		const trailingSlashRedirect = isDataReq ? null : normalizeTrailingSlash(pathname, basePath, trailingSlash, search);
 		if (trailingSlashRedirect) return {
 			type: "response",
 			response: trailingSlashRedirect

package/dist/server/prod-server.d.ts

@@ -1,3 +1,4 @@
+import { negotiateEncoding } from "./accept-encoding.js";
 import { StaticFileCache } from "./static-file-cache.js";
 import { resolveRequestHost, trustProxy, trustedHosts } from "./proxy-trust.js";
 import { IncomingMessage, ServerResponse } from "node:http";
@@ -59,7 +60,6 @@ type ProdServerOptions = {
 declare const COMPRESSIBLE_TYPES: Set<string>;
 /** Minimum size threshold for compression (in bytes). Below this, compression overhead isn't worth it. */
 declare const COMPRESS_THRESHOLD = 1024;
-declare function negotiateEncoding(req: IncomingMessage): "zstd" | "br" | "gzip" | "deflate" | null;
 /**
  * Merge middleware headers and a Web Response's headers into a single
  * record suitable for Node.js `res.writeHead()`. Uses `getSetCookie()`

package/dist/server/prod-server.js

@@ -3,7 +3,8 @@ import { hasBasePath, stripBasePath } from "../utils/base-path.js";
 import { VINEXT_PRERENDER_ROUTE_PARAMS_HEADER, VINEXT_PRERENDER_SECRET_HEADER, VINEXT_STATIC_FILE_HEADER } from "./headers.js";
 import { normalizePath } from "./normalize-path.js";
 import { notFoundResponse } from "./http-error-responses.js";
-import { filterInternalHeaders, isOpenRedirectShaped } from "./request-pipeline.js";
+import { isOpenRedirectShaped } from "./open-redirect.js";
+import { filterInternalHeaders } from "./request-pipeline.js";
 import { isUnknownRecord } from "../utils/record.js";
 import { resolveRequestHost, resolveRequestProtocol, trustProxy, trustedHosts } from "./proxy-trust.js";
 import { DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, isImageOptimizationPath, isSafeImageContentType, parseImageParams } from "./image-optimization.js";
@@ -18,6 +19,7 @@ import { readTrustedPrerenderRouteParamsFromHeaders, serializePrerenderRoutePara
 import { computeClientRuntimeMetadata } from "../utils/client-runtime-metadata.js";
 import { readPrerenderSecret } from "../build/server-manifest.js";
 import { seedMemoryCacheFromPrerender } from "./seed-cache.js";
+import { negotiateEncoding, parseAcceptedEncodings, selectContentEncoding } from "./accept-encoding.js";
 import fs from "node:fs";
 import path from "node:path";
 import fs$1 from "node:fs/promises";
@@ -166,25 +168,6 @@ const COMPRESSIBLE_TYPES = new Set([
 /** Minimum size threshold for compression (in bytes). Below this, compression overhead isn't worth it. */
 const COMPRESS_THRESHOLD = 1024;
 /**
-* Parse the Accept-Encoding header and return the best supported encoding.
-* Preference order: zstd > br > gzip > deflate > identity.
-*
-* zstd decompresses ~3-5x faster than brotli at similar compression ratios.
-* Supported in Chrome 123+, Firefox 126+. Safari can decompress but doesn't
-* send zstd in Accept-Encoding, so it transparently falls back to br/gzip.
-*/
-const HAS_ZSTD = typeof zlib.createZstdCompress === "function";
-function negotiateEncoding(req) {
-	const accept = req.headers["accept-encoding"];
-	if (!accept || typeof accept !== "string") return null;
-	const lower = accept.toLowerCase();
-	if (HAS_ZSTD && lower.includes("zstd")) return "zstd";
-	if (lower.includes("br")) return "br";
-	if (lower.includes("gzip")) return "gzip";
-	if (lower.includes("deflate")) return "deflate";
-	return null;
-}
-/**
 * Create a compression stream for the given encoding.
 */
 function createCompressor(encoding, mode = "default") {
@@ -264,6 +247,23 @@ function omitHeadersCaseInsensitive(headersRecord, targets) {
 	}
 	return filtered;
 }
+function mergeVaryHeader(headers, value) {
+	const merged = { ...headers };
+	const existingKey = Object.keys(merged).find((key) => key.toLowerCase() === "vary");
+	if (!existingKey) {
+		merged.Vary = value;
+		return merged;
+	}
+	const rawVary = merged[existingKey];
+	const existingVary = Array.isArray(rawVary) ? rawVary.join(", ") : rawVary;
+	if (existingVary.trim().length === 0) {
+		merged[existingKey] = value;
+		return merged;
+	}
+	const values = existingVary.split(",").map((entry) => entry.trim().toLowerCase());
+	if (!values.includes("*") && !values.includes(value.toLowerCase())) merged[existingKey] = `${existingVary}, ${value}`;
+	return merged;
+}
 function matchesIfNoneMatchHeader(ifNoneMatch, etag) {
 	if (!ifNoneMatch) return false;
 	if (ifNoneMatch === "*") return true;
@@ -317,33 +317,37 @@ function mergeWebResponse(middlewareHeaders, response, statusOverride) {
 function sendCompressed(req, res, body, contentType, statusCode, extraHeaders = {}, compress = true, statusText) {
 	const buf = typeof body === "string" ? Buffer.from(body) : body;
 	const baseType = contentType.split(";")[0].trim();
-	const encoding = compress ? negotiateEncoding(req) : null;
+	const varyByEncoding = compress && COMPRESSIBLE_TYPES.has(baseType);
+	const encoding = compress ? negotiateEncoding(req) : "identity";
 	const headersWithoutBodyHeaders = omitHeadersCaseInsensitive(extraHeaders, OMIT_BODY_HEADERS);
-	const writeHead = (headers) => {
-		if (statusText) res.writeHead(statusCode, statusText, headers);
-		else res.writeHead(statusCode, headers);
+	const writeHead = (headers, responseStatus = statusCode, responseStatusText = statusText) => {
+		if (responseStatusText) res.writeHead(responseStatus, responseStatusText, headers);
+		else res.writeHead(responseStatus, headers);
 	};
-	if (encoding && COMPRESSIBLE_TYPES.has(baseType) && buf.length >= 1024) {
-		const compressor = createCompressor(encoding);
-		const rawVary = extraHeaders["Vary"] ?? extraHeaders["vary"];
-		const existingVary = Array.isArray(rawVary) ? rawVary.join(", ") : rawVary;
-		let varyValue;
-		if (existingVary) varyValue = existingVary.toLowerCase().includes("accept-encoding") ? existingVary : existingVary + ", Accept-Encoding";
-		else varyValue = "Accept-Encoding";
-		writeHead({
+	if (encoding !== "identity" && varyByEncoding && buf.length >= 1024) {
+		writeHead(mergeVaryHeader({
 			...headersWithoutBodyHeaders,
 			"Content-Type": contentType,
-			"Content-Encoding": encoding,
-			Vary: varyValue
-		});
+			"Content-Encoding": encoding
+		}, "Accept-Encoding"));
+		if (req.method === "HEAD") {
+			res.end();
+			return;
+		}
+		const compressor = createCompressor(encoding);
 		compressor.end(buf);
 		pipeline(compressor, res, () => {});
 	} else {
-		writeHead({
+		const identityHeaders = {
 			...headersWithoutBodyHeaders,
 			"Content-Type": contentType,
 			"Content-Length": String(buf.length)
-		});
+		};
+		writeHead(varyByEncoding ? mergeVaryHeader(identityHeaders, "Accept-Encoding") : identityHeaders);
+		if (req.method === "HEAD") {
+			res.end();
+			return;
+		}
 		res.end(buf);
 	}
 }
@@ -377,24 +381,35 @@ async function tryServeStatic(req, res, clientDir, pathname, compress, cache, ex
 		}
 		const entry = cache.lookup(lookupPath);
 		if (!entry) return false;
+		const rawAe = compress ? req.headers["accept-encoding"] : void 0;
+		const parsed = typeof rawAe === "string" ? parseAcceptedEncodings(rawAe) : void 0;
+		const availableVariants = [
+			...entry.zst ? ["zstd"] : [],
+			...entry.br ? ["br"] : [],
+			...entry.gz ? ["gzip"] : []
+		];
+		const variesByEncoding = compress && availableVariants.length > 0;
+		const selected = parsed ? selectContentEncoding(parsed, availableVariants) : "identity";
+		const variant = selected === "zstd" ? entry.zst : selected === "br" ? entry.br : selected === "gzip" ? entry.gz : entry.original;
 		const ifNoneMatch = req.headers["if-none-match"];
 		if (responseStatus === 200 && typeof ifNoneMatch === "string" && matchesIfNoneMatchHeader(ifNoneMatch, entry.etag)) {
-			if (extraHeaders) res.writeHead(304, {
+			const notModifiedHeaders = variesByEncoding ? mergeVaryHeader({
 				...entry.notModifiedHeaders,
 				...extraHeaders
-			});
-			else res.writeHead(304, entry.notModifiedHeaders);
+			}, "Accept-Encoding") : {
+				...entry.notModifiedHeaders,
+				...extraHeaders
+			};
+			if (selected !== "identity") notModifiedHeaders["Content-Encoding"] = selected;
+			res.writeHead(304, notModifiedHeaders);
 			res.end();
 			return true;
 		}
-		const rawAe = compress ? req.headers["accept-encoding"] : void 0;
-		const ae = typeof rawAe === "string" ? rawAe.toLowerCase() : void 0;
-		const variant = ae ? ae.includes("zstd") && entry.zst || ae.includes("br") && entry.br || ae.includes("gzip") && entry.gz || entry.original : entry.original;
-		if (extraHeaders) res.writeHead(responseStatus, {
+		const responseHeaders = {
 			...variant.headers,
 			...extraHeaders
-		});
-		else res.writeHead(responseStatus, variant.headers);
+		};
+		res.writeHead(responseStatus, variesByEncoding ? mergeVaryHeader(responseHeaders, "Accept-Encoding") : responseHeaders);
 		if (omitBody || req.method === "HEAD") {
 			res.end();
 			return true;
@@ -427,18 +442,6 @@ async function tryServeStatic(req, res, clientDir, pathname, compress, cache, ex
 	const etag = isHashed && etagFromFilenameHash(resolved.path, ext) || `W/"${resolved.size}-${Math.floor(resolved.mtimeMs / 1e3)}"`;
 	const baseType = ct.split(";")[0].trim();
 	const isCompressible = compress && COMPRESSIBLE_TYPES.has(baseType);
-	const ifNoneMatch = req.headers["if-none-match"];
-	if (responseStatus === 200 && typeof ifNoneMatch === "string" && matchesIfNoneMatchHeader(ifNoneMatch, etag)) {
-		const notModifiedHeaders = {
-			ETag: etag,
-			"Cache-Control": cacheControl,
-			...isCompressible ? { Vary: "Accept-Encoding" } : void 0,
-			...extraHeaders
-		};
-		res.writeHead(304, notModifiedHeaders);
-		res.end();
-		return true;
-	}
 	const baseHeaders = {
 		"Content-Type": ct,
 		"Cache-Control": cacheControl,
@@ -447,12 +450,19 @@ async function tryServeStatic(req, res, clientDir, pathname, compress, cache, ex
 	};
 	if (isCompressible) {
 		const encoding = negotiateEncoding(req);
-		if (encoding) {
-			res.writeHead(responseStatus, {
+		const ifNoneMatch = req.headers["if-none-match"];
+		if (responseStatus === 200 && typeof ifNoneMatch === "string" && matchesIfNoneMatchHeader(ifNoneMatch, etag)) {
+			const notModifiedHeaders = mergeVaryHeader(baseHeaders, "Accept-Encoding");
+			if (encoding !== "identity") notModifiedHeaders["Content-Encoding"] = encoding;
+			res.writeHead(304, notModifiedHeaders);
+			res.end();
+			return true;
+		}
+		if (encoding !== "identity") {
+			res.writeHead(responseStatus, mergeVaryHeader({
 				...baseHeaders,
-				"Content-Encoding": encoding,
-				Vary: "Accept-Encoding"
-			});
+				"Content-Encoding": encoding
+			}, "Accept-Encoding"));
 			if (omitBody || req.method === "HEAD") {
 				res.end();
 				return true;
@@ -467,10 +477,17 @@ async function tryServeStatic(req, res, clientDir, pathname, compress, cache, ex
 			return true;
 		}
 	}
-	res.writeHead(responseStatus, {
+	const ifNoneMatch = req.headers["if-none-match"];
+	if (responseStatus === 200 && typeof ifNoneMatch === "string" && matchesIfNoneMatchHeader(ifNoneMatch, etag)) {
+		res.writeHead(304, isCompressible ? mergeVaryHeader(baseHeaders, "Accept-Encoding") : baseHeaders);
+		res.end();
+		return true;
+	}
+	const identityHeaders = {
 		...baseHeaders,
 		"Content-Length": String(resolved.size)
-	});
+	};
+	res.writeHead(responseStatus, isCompressible ? mergeVaryHeader(identityHeaders, "Accept-Encoding") : identityHeaders);
 	if (omitBody || req.method === "HEAD") {
 		res.end();
 		return true;
@@ -567,25 +584,22 @@ async function sendWebResponse(webResponse, req, res, compress) {
 		if (existing !== void 0) nodeHeaders[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
 		else nodeHeaders[key] = value;
 	});
+	const alreadyEncoded = webResponse.headers.get("content-encoding") !== null;
 	if (!webResponse.body) {
 		writeHead(nodeHeaders);
 		res.end();
 		return;
 	}
-	const alreadyEncoded = webResponse.headers.has("content-encoding");
 	const baseType = (webResponse.headers.get("content-type") ?? "").split(";")[0].trim();
-	const encoding = compress && !alreadyEncoded ? negotiateEncoding(req) : null;
-	const shouldCompress = !!(encoding && COMPRESSIBLE_TYPES.has(baseType));
+	const varyByEncoding = compress && !alreadyEncoded && COMPRESSIBLE_TYPES.has(baseType);
+	const encoding = compress && !alreadyEncoded ? negotiateEncoding(req) : "identity";
+	const shouldCompress = encoding !== "identity" && COMPRESSIBLE_TYPES.has(baseType);
 	if (shouldCompress) {
 		delete nodeHeaders["content-length"];
 		delete nodeHeaders["Content-Length"];
 		nodeHeaders["Content-Encoding"] = encoding;
-		const existingVary = nodeHeaders["Vary"] ?? nodeHeaders["vary"];
-		if (existingVary) {
-			if (!String(existingVary).toLowerCase().includes("accept-encoding")) nodeHeaders["Vary"] = existingVary + ", Accept-Encoding";
-		} else nodeHeaders["Vary"] = "Accept-Encoding";
 	}
-	writeHead(nodeHeaders);
+	writeHead(varyByEncoding ? mergeVaryHeader(nodeHeaders, "Accept-Encoding") : nodeHeaders);
 	if (req.method === "HEAD") {
 		cancelResponseBody(webResponse);
 		res.end();

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

@@ -1,6 +1,7 @@
 import { NextHeader } from "../config/next-config.js";
 import { BasePathMatchState, RequestContext } from "../config/config-matchers.js";
 import { INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS } from "./headers.js";
+import { isOpenRedirectShaped } from "./open-redirect.js";
 import { hasBasePath, stripBasePath } from "../utils/base-path.js";
 
 //#region src/server/request-pipeline.d.ts
@@ -42,30 +43,6 @@ import { hasBasePath, stripBasePath } from "../utils/base-path.js";
  * @returns A 404 Response if the path is protocol-relative, or null to continue
  */
 declare function guardProtocolRelativeUrl(rawPathname: string): Response | null;
-/**
- * Returns true if a request pathname looks like a protocol-relative open
- * redirect, in either literal or percent-encoded form.
- *
- * Exported for call sites that need to replicate the guard inline (Pages
- * Router worker codegen, Node production server) and for defense-in-depth
- * checks inside redirect emitters.
- *
- * A pathname is considered "open redirect shaped" when its first segment,
- * after decoding backslashes and encoded delimiters, would cause a browser
- * to resolve a `Location` containing the pathname as protocol-relative:
- *
- *   - literal   `//evil.com`
- *   - literal   `/\evil.com`             (browsers normalize `\` to `/`)
- *   - encoded   `/%5Cevil.com`           (`%5C` decodes to `\` in Location)
- *   - encoded   `/%2F/evil.com`          (`%2F` decodes to `/` → `//`)
- *   - mixed     `/%5C%2F`, `/%5C%5C`     (and other combinations)
- *
- * We explicitly do not require a valid percent sequence elsewhere in the
- * pathname — we only examine the leading bytes (up to the second real or
- * encoded delimiter) so malformed suffixes can still reach the normal
- * "400 Bad Request" decode path instead of being masked as "404".
- */
-declare function isOpenRedirectShaped(rawPathname: string): boolean;
 type HeaderRecord = Record<string, string | string[]>;
 type ApplyConfigHeadersOptions = {
   configHeaders: NextHeader[];

package/dist/server/request-pipeline.js

@@ -2,6 +2,7 @@ import { hasBasePath, removeTrailingSlash, stripBasePath } from "../utils/base-p
 import { INTERNAL_HEADERS, VINEXT_INTERNAL_HEADERS, VINEXT_STATIC_FILE_HEADER } from "./headers.js";
 import { matchHeaders } from "../config/config-matchers.js";
 import { forbiddenResponse, notFoundResponse } from "./http-error-responses.js";
+import { isOpenRedirectShaped } from "./open-redirect.js";
 //#region src/server/request-pipeline.ts
 /**
 * Shared request pipeline utilities.
@@ -44,39 +45,6 @@ function guardProtocolRelativeUrl(rawPathname) {
 	if (isOpenRedirectShaped(rawPathname)) return notFoundResponse();
 	return null;
 }
-/**
-* Returns true if a request pathname looks like a protocol-relative open
-* redirect, in either literal or percent-encoded form.
-*
-* Exported for call sites that need to replicate the guard inline (Pages
-* Router worker codegen, Node production server) and for defense-in-depth
-* checks inside redirect emitters.
-*
-* A pathname is considered "open redirect shaped" when its first segment,
-* after decoding backslashes and encoded delimiters, would cause a browser
-* to resolve a `Location` containing the pathname as protocol-relative:
-*
-*   - literal   `//evil.com`
-*   - literal   `/\evil.com`             (browsers normalize `\` to `/`)
-*   - encoded   `/%5Cevil.com`           (`%5C` decodes to `\` in Location)
-*   - encoded   `/%2F/evil.com`          (`%2F` decodes to `/` → `//`)
-*   - mixed     `/%5C%2F`, `/%5C%5C`     (and other combinations)
-*
-* We explicitly do not require a valid percent sequence elsewhere in the
-* pathname — we only examine the leading bytes (up to the second real or
-* encoded delimiter) so malformed suffixes can still reach the normal
-* "400 Bad Request" decode path instead of being masked as "404".
-*/
-function isOpenRedirectShaped(rawPathname) {
-	if (!rawPathname.startsWith("/")) return false;
-	const afterSlash = rawPathname.slice(1);
-	if (afterSlash.startsWith("/") || afterSlash.startsWith("\\")) return true;
-	if (afterSlash.length >= 3 && afterSlash[0] === "%") {
-		const encoded = afterSlash.slice(0, 3).toLowerCase();
-		if (encoded === "%5c" || encoded === "%2f") return true;
-	}
-	return false;
-}
 const FILE_LIKE_PATHNAME_RE = /\.[^/]+\/?$/;
 function isWellKnownPathname(pathname) {
 	return pathname === "/.well-known" || pathname.startsWith("/.well-known/");

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

@@ -1,4 +1,4 @@
-import { CachedAppPageValue } from "../shims/cache.js";
+import { CachedAppPageValue } from "../shims/cache-handler.js";
 
 //#region src/server/seed-cache.d.ts
 type PrerenderCacheSeedMetadata = {

package/dist/shims/cache-handler.d.ts

@@ -0,0 +1,106 @@
+import { RenderObservation } from "../server/cache-proof.js";
+
+//#region src/shims/cache-handler.d.ts
+type CacheHandlerValue = {
+  lastModified: number;
+  age?: number;
+  cacheState?: string;
+  cacheControl?: CacheControlMetadata;
+  value: IncrementalCacheValue | null;
+};
+type CacheControlMetadata = {
+  revalidate: number;
+  expire?: number;
+};
+type IncrementalCacheValue = CachedFetchValue | CachedAppPageValue | CachedPagesValue | CachedRouteValue | CachedRedirectValue | CachedImageValue;
+type CachedFetchValue = {
+  kind: "FETCH";
+  data: {
+    headers: Record<string, string>;
+    body: string;
+    url: string;
+    status?: number;
+  };
+  tags?: string[];
+  revalidate: number | false;
+};
+type CachedAppPageValue = {
+  kind: "APP_PAGE";
+  html: string;
+  rscData: ArrayBuffer | undefined;
+  headers: Record<string, string | string[]> | undefined;
+  postponed: string | undefined;
+  renderObservation?: RenderObservation;
+  status: number | undefined;
+};
+type CachedPagesValue = {
+  kind: "PAGES";
+  html: string;
+  pageData: object;
+  generatedFromDataRequest?: boolean;
+  headers: Record<string, string | string[]> | undefined;
+  status: number | undefined;
+};
+type CachedRouteValue = {
+  kind: "APP_ROUTE";
+  body: ArrayBuffer;
+  status: number;
+  headers: Record<string, string | string[]>;
+};
+type CachedRedirectValue = {
+  kind: "REDIRECT";
+  props: object;
+};
+type CachedImageValue = {
+  kind: "IMAGE";
+  etag: string;
+  buffer: ArrayBuffer;
+  extension: string;
+  revalidate?: number;
+};
+type CacheHandlerContext = {
+  dev?: boolean;
+  maxMemoryCacheSize?: number;
+  revalidatedTags?: string[];
+  [key: string]: unknown;
+};
+type CacheHandler = {
+  get(key: string, ctx?: Record<string, unknown>): Promise<CacheHandlerValue | null>;
+  set(key: string, data: IncrementalCacheValue | null, ctx?: Record<string, unknown>): Promise<void>;
+  revalidateTag(tags: string | string[], durations?: {
+    expire?: number;
+  }): Promise<void>;
+  resetRequestCache?(): void;
+};
+declare class NoOpCacheHandler implements CacheHandler {
+  get(_key: string, _ctx?: Record<string, unknown>): Promise<CacheHandlerValue | null>;
+  set(_key: string, _data: IncrementalCacheValue | null, _ctx?: Record<string, unknown>): Promise<void>;
+  revalidateTag(_tags: string | string[], _durations?: {
+    expire?: number;
+  }): Promise<void>;
+}
+type MemoryCacheHandlerOptions = Pick<CacheHandlerContext, "maxMemoryCacheSize"> & {
+  cacheMaxMemorySize?: number;
+};
+declare class MemoryCacheHandler implements CacheHandler {
+  private store;
+  private tagRevalidatedAt;
+  private readonly maxMemoryCacheSize;
+  private currentMemoryCacheSize;
+  constructor(options?: number | MemoryCacheHandlerOptions);
+  private estimateEntrySize;
+  private deleteEntry;
+  private touchEntry;
+  private evictLeastRecentlyUsed;
+  get(key: string, ctx?: Record<string, unknown>): Promise<CacheHandlerValue | null>;
+  set(key: string, data: IncrementalCacheValue | null, ctx?: Record<string, unknown>): Promise<void>;
+  revalidateTag(tags: string | string[]): Promise<void>;
+  resetRequestCache(): void;
+}
+declare function configureMemoryCacheHandler(options?: MemoryCacheHandlerOptions): void;
+declare function setDataCacheHandler(handler: CacheHandler): void;
+declare function getDataCacheHandler(): CacheHandler;
+declare function setCacheHandler(handler: CacheHandler): void;
+declare function getCacheHandler(): CacheHandler;
+//#endregion
+export { CacheControlMetadata, CacheHandler, CacheHandlerContext, CacheHandlerValue, CachedAppPageValue, CachedFetchValue, CachedImageValue, CachedPagesValue, CachedRedirectValue, CachedRouteValue, IncrementalCacheValue, MemoryCacheHandler, NoOpCacheHandler, configureMemoryCacheHandler, getCacheHandler, getDataCacheHandler, setCacheHandler, setDataCacheHandler };