vinext 1.0.0-beta.8 → 1.0.0

package/dist/server/cacheability-request.js

@@ -0,0 +1,559 @@
+import "../utils/protocol-headers.js";
+import { isVinextRscVaryField } from "./app-rsc-vary.js";
+import { VINEXT_CACHEABILITY_PROBE_HEADER, VINEXT_CACHEABILITY_PROBE_ROUTE_HEADER } from "./headers.js";
+import { isNonCacheableCacheControl } from "../shims/cdn-cache.js";
+import { CACHEABILITY_REQUEST_STATE, recordConfigCdnCachePolicyHeader } from "../shims/cacheability-classification.js";
+import { NO_STORE_CACHE_CONTROL, applyCdnResponseBuildIdentityHeaders, applyCdnResponseHeaders, hasExplicitNonCacheableResponsePolicy, isCdnResponsePolicyHeader, readCdnResponseCacheControl, readCdnResponsePolicyHeaderName } from "./cache-control.js";
+import { cacheabilityManifestPageState, cacheabilityManifestRouteState, cacheabilityRepresentationMatchesPageRoute, cacheabilityRequestIdentity, cacheabilityRoutePathname, findCacheabilityManifestRoute, parseCacheabilityManifest, resolveCacheabilityRepresentation } from "./cacheability-manifest.js";
+import { workerCapabilityMatches } from "./worker-prerender-discovery.js";
+import { CACHEABILITY_ADMISSION_ISOLATE_BODY_LIMIT, CACHEABILITY_ADMISSION_RESPONSE_BODY_LIMIT, CACHEABILITY_PROBE_TIMEOUT_MS } from "./cacheability-limits.js";
+import { applyResponseStagePolicyHeaders } from "./response-stage-policy.js";
+//#region src/server/cacheability-request.ts
+function cacheabilityVaryRejectionReason(headers, state) {
+	const fields = (headers.get("Vary") ?? "").split(",").map((name) => name.trim().toLowerCase()).filter(Boolean);
+	if (fields.includes("*")) return "response uses Vary: *";
+	if (state.responseVary === "verbatim") return null;
+	return fields.some((name) => !isVinextRscVaryField(name)) ? "response cache does not support custom Vary fields" : null;
+}
+/** Encode the trusted route identity carried by a staged probe request. */
+function serializeWorkerCacheabilityProbeRoute(route) {
+	return encodeURIComponent(JSON.stringify([route.kind, route.pattern]));
+}
+/** Read route identity only after the surrounding probe request is authenticated. */
+function readWorkerCacheabilityProbeRoute(request) {
+	const raw = request.headers.get(VINEXT_CACHEABILITY_PROBE_ROUTE_HEADER);
+	if (!raw) return null;
+	try {
+		const value = JSON.parse(decodeURIComponent(raw));
+		if (!Array.isArray(value) || value.length !== 2) return null;
+		const [kind, pattern] = value;
+		if (kind !== "app-page" && kind !== "app-route" && kind !== "pages-page" || typeof pattern !== "string" || !pattern.startsWith("/")) return null;
+		return {
+			kind,
+			pattern
+		};
+	} catch {
+		return null;
+	}
+}
+/** Authenticate and read the cacheability probe mode before internal headers are filtered. */
+function readWorkerCacheabilityProbeMode(request, expectedSecret) {
+	const requestedMode = request.headers.get(VINEXT_CACHEABILITY_PROBE_HEADER);
+	if (requestedMode !== "1" && requestedMode !== "identity") return null;
+	if (!expectedSecret || !workerCapabilityMatches(request.headers.get("x-vinext-prerender-secret") ?? "", expectedSecret)) return null;
+	return requestedMode === "identity" ? "identity" : "probe";
+}
+/** Create probe state from a mode that was authenticated at the request boundary. */
+function createWorkerCacheabilityProbeContext(base, mode, responseVary, resolvedRoutePathname) {
+	const state = {
+		captureDeadlineAt: Date.now() + CACHEABILITY_PROBE_TIMEOUT_MS,
+		mode,
+		responseVary,
+		resolvedRoutePathname
+	};
+	return Object.assign(Object.create(Object.getPrototypeOf(base)), base, { [CACHEABILITY_REQUEST_STATE]: state });
+}
+function createWorkerCacheabilityContext(base, request, expectedSecret, responseVary) {
+	const mode = readWorkerCacheabilityProbeMode(request, expectedSecret);
+	return mode ? createWorkerCacheabilityProbeContext(base, mode, responseVary) : base;
+}
+let cachedManifest;
+function readBoundManifest(raw, buildId) {
+	if (cachedManifest?.raw === raw && cachedManifest.buildId === buildId) return cachedManifest.manifest;
+	const manifest = parseCacheabilityManifest(raw, buildId);
+	cachedManifest = {
+		buildId,
+		manifest,
+		raw
+	};
+	return manifest;
+}
+function createWorkerCacheabilityAdmissionContext(base, request, rawManifest, buildId, requiresCompletedResponseAdmission = rawManifest != null, responseVary, resolvedRoutePathname, trustedRepresentation, options) {
+	const identity = cacheabilityRequestIdentity(request, trustedRepresentation);
+	const credentialedRequest = request.headers.has("authorization") || request.headers.has("cookie") || request.headers.has("proxy-authorization");
+	const routePathname = identity ? cacheabilityRoutePathname(resolvedRoutePathname ?? new URL(request.url).pathname, identity.representation) : void 0;
+	if (!rawManifest) {
+		if (!requiresCompletedResponseAdmission) return base;
+		const state = {
+			admission: identity ? {
+				policy: "runtime",
+				...identity,
+				routePathname
+			} : { policy: "deny" },
+			captureDeadlineAt: Date.now() + CACHEABILITY_PROBE_TIMEOUT_MS,
+			credentialedRequest,
+			mode: "admit",
+			applyCompletedResponsePolicy: options?.applyCompletedResponsePolicy,
+			responseVary
+		};
+		return Object.assign(Object.create(Object.getPrototypeOf(base)), base, { [CACHEABILITY_REQUEST_STATE]: state });
+	}
+	const manifest = buildId ? readBoundManifest(rawManifest, buildId) : null;
+	const state = {
+		admission: manifest && identity ? {
+			manifest,
+			policy: "manifest",
+			...identity,
+			routePathname
+		} : { policy: "deny" },
+		captureDeadlineAt: Date.now() + CACHEABILITY_PROBE_TIMEOUT_MS,
+		credentialedRequest,
+		mode: "admit",
+		applyCompletedResponsePolicy: options?.applyCompletedResponsePolicy,
+		responseVary
+	};
+	return Object.assign(Object.create(Object.getPrototypeOf(base)), base, { [CACHEABILITY_REQUEST_STATE]: state });
+}
+function readState(ctx) {
+	return Reflect.get(ctx, CACHEABILITY_REQUEST_STATE) ?? null;
+}
+/** Apply request-stage-vetted positive config policy inside the admission boundary. */
+function applyResponseStageCachePolicy(response, ctx, policyHeaders) {
+	if (!policyHeaders?.length) return response;
+	recordConfigCachePolicy(readState(ctx), policyHeaders);
+	try {
+		applyResponseStagePolicyHeaders(response.headers, policyHeaders);
+		return response;
+	} catch {
+		const headers = new Headers(response.headers);
+		applyResponseStagePolicyHeaders(headers, policyHeaders);
+		return new Response(response.body, {
+			headers,
+			status: response.status,
+			statusText: response.statusText
+		});
+	}
+}
+/** Record policy that a renderer applied before producing its response. */
+function recordResponseStageCachePolicy(ctx, policyHeaders) {
+	if (!policyHeaders?.length) return;
+	recordConfigCachePolicy(readState(ctx), policyHeaders);
+}
+function recordConfigCachePolicy(state, policyHeaders) {
+	if (!state) return;
+	state.explicitConfigCachePolicy = true;
+	for (const [name, value] of policyHeaders) if (isCdnResponsePolicyHeader(name)) recordConfigCdnCachePolicyHeader(state, name, value);
+}
+function probeResponse(state, routeState, outcome, status, renderer) {
+	const dynamicUsage = renderer?.dynamicUsage === true || outcome.dynamicUsage === true || state.patternDynamicReason !== void 0;
+	const body = {
+		cacheControl: outcome.cacheControl,
+		...dynamicUsage ? { dynamicUsage: true } : {},
+		...state.explicitConfigCachePolicy ? { explicitConfigCachePolicy: true } : {},
+		kind: state.route?.kind,
+		pattern: state.route?.pattern,
+		reason: outcome.reason,
+		...renderer ? { rendererStatic: renderer.static } : {},
+		...outcome.retryable ? { retryable: true } : {},
+		...state.resolvedRoutePathname ? { routePathname: state.resolvedRoutePathname } : {},
+		...routeState === "dynamic" ? { scope: state.patternDynamicReason ? "pattern" : "identity" } : {},
+		state: routeState,
+		status,
+		version: 1
+	};
+	return applyCdnResponseBuildIdentityHeaders(Response.json(body, { headers: { "Cache-Control": NO_STORE_CACHE_CONTROL } }));
+}
+/**
+* Convert an authenticated probe that terminated in request routing into a
+* valid identity-scoped dynamic result. Middleware redirects, custom responses,
+* and external rewrites never reach the reusable response stage.
+*/
+function finalizeRequestStageCacheabilityProbe(response, options) {
+	if (!options.mode || options.responseStageDispatched || !options.route) return response;
+	response.body?.cancel().catch(() => {});
+	const body = {
+		kind: options.route.kind,
+		pattern: options.route.pattern,
+		reason: "request routing completed without response-stage rendering",
+		scope: "identity",
+		state: "dynamic",
+		status: response.status,
+		terminal: true,
+		version: 1
+	};
+	return applyCdnResponseBuildIdentityHeaders(Response.json(body, { headers: { "Cache-Control": NO_STORE_CACHE_CONTROL } }));
+}
+async function drainProbeBody(response, deadlineAt) {
+	if (!response.body) return null;
+	const reader = response.body.getReader();
+	let timeout;
+	try {
+		while (true) {
+			const remaining = deadlineAt - Date.now();
+			if (remaining <= 0) return "response body did not complete before the probe deadline";
+			const result = await Promise.race([reader.read(), new Promise((_, reject) => {
+				timeout = setTimeout(() => reject(/* @__PURE__ */ new Error("response body did not complete before the probe deadline")), remaining);
+			})]);
+			if (timeout !== void 0) {
+				clearTimeout(timeout);
+				timeout = void 0;
+			}
+			if (result.done) return null;
+		}
+	} catch (error) {
+		return error instanceof Error ? error.message : String(error);
+	} finally {
+		if (timeout !== void 0) clearTimeout(timeout);
+		reader.cancel().catch(() => {});
+		try {
+			reader.releaseLock();
+		} catch {}
+	}
+}
+const isolateCaptureBudget = {
+	maxBytes: CACHEABILITY_ADMISSION_ISOLATE_BODY_LIMIT,
+	reservedBytes: 0
+};
+function createCacheabilityAdmissionCaptureBudget(maxBytes) {
+	return {
+		maxBytes,
+		reservedBytes: 0
+	};
+}
+function reserveChunk(budget, byteLength) {
+	if (byteLength > budget.maxBytes - budget.reservedBytes) return false;
+	budget.reservedBytes += byteLength;
+	return true;
+}
+function releaseChunk(budget, chunk) {
+	if (!chunk.reserved) return;
+	chunk.reserved = false;
+	budget.reservedBytes -= chunk.value.byteLength;
+}
+function releaseChunks(budget, chunks, start = 0) {
+	for (let index = start; index < chunks.length; index++) releaseChunk(budget, chunks[index]);
+}
+async function readBeforeDeadline(promise, deadlineAt) {
+	const remaining = deadlineAt - Date.now();
+	if (remaining <= 0) return { kind: "timeout" };
+	let timeout;
+	try {
+		return await Promise.race([promise.then((value) => ({
+			kind: "value",
+			value
+		})), new Promise((resolve) => {
+			timeout = setTimeout(() => resolve({ kind: "timeout" }), remaining);
+		})]);
+	} finally {
+		if (timeout !== void 0) clearTimeout(timeout);
+	}
+}
+function continueCapturedBody(reader, captured, budget, pendingRead) {
+	let index = 0;
+	let released = false;
+	const release = () => {
+		if (released) return;
+		released = true;
+		try {
+			reader.releaseLock();
+		} catch {}
+	};
+	return new ReadableStream({
+		async pull(controller) {
+			if (index < captured.length) {
+				const chunk = captured[index++];
+				controller.enqueue(chunk.value);
+				releaseChunk(budget, chunk);
+				return;
+			}
+			try {
+				const result = await (pendingRead ?? reader.read());
+				pendingRead = void 0;
+				if (result.done) {
+					release();
+					controller.close();
+				} else controller.enqueue(result.value);
+			} catch (error) {
+				release();
+				controller.error(error);
+			}
+		},
+		cancel(reason) {
+			releaseChunks(budget, captured, index);
+			try {
+				reader.cancel(reason).catch(() => {}).finally(release);
+			} catch {
+				release();
+			}
+		}
+	}, { highWaterMark: 0 });
+}
+function replayCapturedBody(captured, budget) {
+	let index = 0;
+	return new ReadableStream({
+		pull(controller) {
+			if (index >= captured.length) {
+				controller.close();
+				return;
+			}
+			const chunk = captured[index++];
+			controller.enqueue(chunk.value);
+			releaseChunk(budget, chunk);
+		},
+		cancel() {
+			releaseChunks(budget, captured, index);
+		}
+	}, { highWaterMark: 0 });
+}
+async function captureCacheabilityAdmissionBody(body, deadlineAt, limit = CACHEABILITY_ADMISSION_RESPONSE_BODY_LIMIT, budget = isolateCaptureBudget) {
+	if (!body) return {
+		body: null,
+		kind: "captured"
+	};
+	const reader = body.getReader();
+	const chunks = [];
+	let total = 0;
+	try {
+		while (true) {
+			const pendingRead = reader.read();
+			const deadlineResult = await readBeforeDeadline(pendingRead, deadlineAt);
+			if (deadlineResult.kind === "timeout") return {
+				body: continueCapturedBody(reader, chunks, budget, pendingRead),
+				kind: "fallback"
+			};
+			const result = deadlineResult.value;
+			if (result.done) {
+				reader.releaseLock();
+				return {
+					body: replayCapturedBody(chunks, budget),
+					kind: "captured"
+				};
+			}
+			const nextTotal = total + result.value.byteLength;
+			const reserved = nextTotal <= limit && reserveChunk(budget, result.value.byteLength);
+			chunks.push({
+				reserved,
+				value: result.value
+			});
+			total = nextTotal;
+			if (!reserved) return {
+				body: continueCapturedBody(reader, chunks, budget),
+				kind: "fallback"
+			};
+		}
+	} catch (error) {
+		releaseChunks(budget, chunks);
+		const release = () => {
+			try {
+				reader.releaseLock();
+			} catch {}
+		};
+		try {
+			const cancellation = reader.cancel(error);
+			release();
+			cancellation.catch(() => {}).finally(release);
+		} catch {
+			release();
+		}
+		throw error;
+	}
+}
+function responseWithCachePolicy(response, body, outcome) {
+	const headers = new Headers(response.headers);
+	if (typeof body === "string") headers.delete("Content-Length");
+	applyCdnResponseHeaders(headers, outcome?.cacheable === true && outcome.cacheControl ? {
+		cacheControl: outcome.cacheControl,
+		tags: outcome.tags
+	} : { cacheControl: NO_STORE_CACHE_CONTROL });
+	return new Response(body, {
+		headers,
+		status: response.status,
+		statusText: response.statusText
+	});
+}
+async function stripSharedHtmlClientTraceMetadata(body, marker) {
+	if (!body) return null;
+	const html = await new Response(body).text();
+	const { stripClientTraceMetadataBlock } = await import("./client-trace-metadata.js");
+	return stripClientTraceMetadataBlock(html, marker);
+}
+function inferFinalAppPageCacheability(response, state) {
+	if (!state.explicitConfigCachePolicy && !state.frameworkResponseCachePolicy) return null;
+	const cacheControl = readCdnResponseCacheControl(response.headers);
+	if (cacheControl === null || !state.explicitConfigCachePolicy && cacheControl === readCdnResponseCacheControl(state.frameworkResponseCachePolicy)) return null;
+	if (isNonCacheableCacheControl(cacheControl)) return { cacheable: false };
+	return {
+		cacheable: true,
+		cacheControl,
+		...state.cdnCacheTags ? { tags: state.cdnCacheTags } : {}
+	};
+}
+function inferPagesPageCacheability(response, state) {
+	const cacheControl = readCdnResponseCacheControl(response.headers);
+	if (!cacheControl || isNonCacheableCacheControl(cacheControl)) return { cacheable: false };
+	return {
+		cacheable: true,
+		cacheControl,
+		...state.cdnCacheTags ? { tags: state.cdnCacheTags } : {}
+	};
+}
+function completedRouteOutcome(response, state, rendererOutcome = state.outcome ?? null) {
+	if (state.forcedDynamicReason) return {
+		cacheable: false,
+		reason: state.forcedDynamicReason
+	};
+	const varyRejectionReason = cacheabilityVaryRejectionReason(response.headers, state);
+	if (varyRejectionReason) return {
+		cacheable: false,
+		reason: varyRejectionReason
+	};
+	if (state.route?.kind === "app-route") {
+		if (response.headers.has("set-cookie")) return {
+			cacheable: false,
+			reason: "response sets a cookie"
+		};
+		return inferPagesPageCacheability(response, state);
+	}
+	if (state.route?.kind === "app-page") return inferFinalAppPageCacheability(response, state) ?? rendererOutcome;
+	if (state.route?.kind !== "pages-page") return rendererOutcome;
+	if (response.headers.has("set-cookie") || hasExplicitNonCacheableResponsePolicy(response.headers)) return { cacheable: false };
+	const responseOutcome = inferPagesPageCacheability(response, state);
+	return responseOutcome.cacheable ? responseOutcome : rendererOutcome ?? responseOutcome;
+}
+function staticToDynamicResponse(route) {
+	const headers = new Headers({ "Content-Type": "text/plain; charset=utf-8" });
+	applyCdnResponseHeaders(headers, { cacheControl: NO_STORE_CACHE_CONTROL });
+	return new Response(`[vinext] Route ${route.pattern} changed from static to dynamic after deployment.`, {
+		headers,
+		status: 500
+	});
+}
+function cacheabilityEvaluationFailureResponse(pattern) {
+	const headers = new Headers({ "Content-Type": "text/plain; charset=utf-8" });
+	applyCdnResponseHeaders(headers, { cacheControl: NO_STORE_CACHE_CONTROL });
+	return new Response(`[vinext] Route ${pattern} failed during cacheability evaluation.`, {
+		headers,
+		status: 500
+	});
+}
+function hasStrictFinalResponseVeto(response, state) {
+	if (state.finalResponseVetoReason || response.headers.has("set-cookie")) return true;
+	return hasExplicitNonCacheableResponsePolicy(response.headers, state.frameworkResponseCachePolicy);
+}
+async function finalizeWorkerCacheabilityAdmission(response, state) {
+	if (state.preserveResponseCachePolicy) return response;
+	const admission = state.admission;
+	if (state.route?.kind === "app-route" || state.route?.kind === "pages-api") {
+		let manifestRoute = null;
+		const responseOutcome = inferPagesPageCacheability(response, state);
+		const representation = admission?.representation ? resolveCacheabilityRepresentation(admission.representation, state.route.kind) : null;
+		const hasExplicitRuntimePolicy = state.explicitResponseCachePolicy === true || state.explicitConfigCachePolicy === true || state.route.kind === "pages-api" && responseOutcome.cacheable;
+		if (!admission || admission.policy === "deny" || !representation || !admission.requestKey) return responseWithCachePolicy(response, response.body, null);
+		if (admission.policy === "manifest" && state.route.kind === "app-route") {
+			const manifest = admission.manifest;
+			manifestRoute = findCacheabilityManifestRoute(manifest, state.route.kind, state.route.pattern);
+		}
+		const isManifestAuthorized = manifestRoute !== null && admission.routePathname !== void 0 && cacheabilityManifestRouteState(manifestRoute, admission.routePathname, representation) !== null;
+		const canUseBoundedRuntimeAdmission = hasExplicitRuntimePolicy && (admission.policy === "runtime" || admission.policy === "manifest" && !isManifestAuthorized);
+		if (!isManifestAuthorized && !canUseBoundedRuntimeAdmission || response.status >= 500 || state.credentialedRequest || state.forcedDynamicReason || hasStrictFinalResponseVeto(response, state) || cacheabilityVaryRejectionReason(response.headers, state) !== null) return responseWithCachePolicy(response, response.body, null);
+		const outcome = responseOutcome;
+		if (!outcome.cacheable || !outcome.cacheControl) return responseWithCachePolicy(response, response.body, null);
+		if (state.completedResponseBody) {
+			if (!state.applyCompletedResponsePolicy) return response;
+			return responseWithCachePolicy(response, response.body, outcome);
+		}
+		let captured;
+		try {
+			captured = await captureCacheabilityAdmissionBody(response.body, state.captureDeadlineAt, CACHEABILITY_ADMISSION_RESPONSE_BODY_LIMIT, state.captureBudget ?? isolateCaptureBudget);
+		} catch {
+			return cacheabilityEvaluationFailureResponse(state.route.pattern);
+		}
+		if (captured.kind === "fallback") return responseWithCachePolicy(response, captured.body, null);
+		return responseWithCachePolicy(response, captured.body, outcome);
+	}
+	if (!admission || admission.policy === "deny" || !admission.representation || !admission.requestKey || !state.route || response.status >= 500) return responseWithCachePolicy(response, response.body, null);
+	const pageRoute = {
+		kind: state.route.kind,
+		pattern: state.route.pattern
+	};
+	const requestRepresentation = admission.representation;
+	const representation = resolveCacheabilityRepresentation(requestRepresentation, pageRoute.kind);
+	if (!cacheabilityRepresentationMatchesPageRoute(pageRoute.kind, representation)) return responseWithCachePolicy(response, response.body, null);
+	let manifestRoute = null;
+	let manifestRouteState = null;
+	if (admission.policy === "manifest") {
+		const manifest = admission.manifest;
+		manifestRoute = findCacheabilityManifestRoute(manifest, pageRoute.kind, pageRoute.pattern);
+		manifestRouteState = admission.routePathname ? cacheabilityManifestPageState(manifest, pageRoute, requestRepresentation, admission.routePathname) : null;
+		if (!manifestRoute || !manifestRouteState) return responseWithCachePolicy(response, response.body, null);
+	}
+	if (state.forcedDynamicReason) return responseWithCachePolicy(response, response.body, null);
+	if (hasStrictFinalResponseVeto(response, state)) return responseWithCachePolicy(response, response.body, null);
+	if (cacheabilityVaryRejectionReason(response.headers, state) !== null) return responseWithCachePolicy(response, response.body, null);
+	let captured;
+	try {
+		captured = await captureCacheabilityAdmissionBody(response.body, state.captureDeadlineAt, CACHEABILITY_ADMISSION_RESPONSE_BODY_LIMIT, state.captureBudget ?? isolateCaptureBudget);
+	} catch {
+		return cacheabilityEvaluationFailureResponse(state.route.pattern);
+	}
+	if (captured.kind === "fallback") return responseWithCachePolicy(response, captured.body, null);
+	const rendererOutcome = state.completion ? await state.completion : state.outcome ?? null;
+	const outcome = completedRouteOutcome(response, state, rendererOutcome);
+	if (outcome?.cacheable !== true || !outcome.cacheControl) {
+		if (manifestRoute && manifestRouteState === "static-candidate" && outcome?.dynamicUsage === true) {
+			await captured.body?.cancel().catch(() => {});
+			return staticToDynamicResponse(manifestRoute);
+		}
+		return responseWithCachePolicy(response, captured.body, null);
+	}
+	const effectivePolicyHeader = readCdnResponsePolicyHeaderName(response.headers);
+	const replacesRendererPolicy = outcome !== rendererOutcome && effectivePolicyHeader !== null && state.configCdnCachePolicy?.get(effectivePolicyHeader) === response.headers.get(effectivePolicyHeader);
+	if (state.route.kind === "app-page" && !replacesRendererPolicy && rendererOutcome?.searchParamsUnread !== true) return responseWithCachePolicy(response, captured.body, null);
+	return responseWithCachePolicy(response, representation === "html" && state.clientTraceMetadataMarker ? await stripSharedHtmlClientTraceMetadata(captured.body, state.clientTraceMetadataMarker) : captured.body, outcome);
+}
+async function finalizeWorkerCacheabilityResponse(response, ctx) {
+	const state = readState(ctx);
+	if (!state) return response;
+	if (state.mode === "admit") return finalizeWorkerCacheabilityAdmission(response, state);
+	if (state.mode === "identity") {
+		await response.body?.cancel().catch(() => {});
+		return probeResponse(state, state.route ? "runtime-check" : "probe-failed", state.route ? { cacheable: false } : {
+			cacheable: false,
+			reason: "request did not resolve to a probeable page route"
+		}, response.status);
+	}
+	if (!state.route) {
+		await response.body?.cancel().catch(() => {});
+		return probeResponse(state, "probe-failed", {
+			cacheable: false,
+			reason: "request did not resolve to a probeable page route"
+		}, response.status);
+	}
+	if (state.probeBailout?.kind === "private-cache") {
+		await response.body?.cancel().catch(() => {});
+		return probeResponse(state, "dynamic", state.probeBailout.outcome, response.status);
+	}
+	if (response.status >= 500) {
+		await response.body?.cancel().catch(() => {});
+		return probeResponse(state, "probe-failed", {
+			cacheable: false,
+			reason: `route returned HTTP ${response.status}`
+		}, response.status);
+	}
+	if (state.patternDynamicReason && !state.explicitConfigCachePolicy) {
+		await response.body?.cancel().catch(() => {});
+		return probeResponse(state, "dynamic", {
+			cacheable: false,
+			reason: state.patternDynamicReason
+		}, response.status);
+	}
+	const drainFailure = await drainProbeBody(response, state.captureDeadlineAt);
+	if (drainFailure) return probeResponse(state, "probe-failed", {
+		cacheable: false,
+		classificationFailure: true,
+		reason: drainFailure,
+		retryable: true
+	}, response.status);
+	const rendererOutcome = state.completion ? await state.completion : state.outcome ?? null;
+	const outcome = completedRouteOutcome(response, state, rendererOutcome);
+	if (!outcome) return probeResponse(state, "dynamic", {
+		cacheable: false,
+		reason: "completed render did not produce a reusable cache policy"
+	}, response.status);
+	return probeResponse(state, outcome.cacheable ? "static-candidate" : outcome.classificationFailure ? "probe-failed" : "dynamic", outcome, response.status, {
+		dynamicUsage: rendererOutcome?.dynamicUsage === true,
+		static: rendererOutcome?.cacheable === true && rendererOutcome.dynamicUsage !== true
+	});
+}
+//#endregion
+export { applyResponseStageCachePolicy, captureCacheabilityAdmissionBody, createCacheabilityAdmissionCaptureBudget, createWorkerCacheabilityAdmissionContext, createWorkerCacheabilityContext, createWorkerCacheabilityProbeContext, finalizeRequestStageCacheabilityProbe, finalizeWorkerCacheabilityResponse, readWorkerCacheabilityProbeMode, readWorkerCacheabilityProbeRoute, recordResponseStageCachePolicy, serializeWorkerCacheabilityProbeRoute };

package/dist/server/client-reuse-manifest.d.ts

@@ -1,8 +1,8 @@
 import { ArtifactCompatibilityEnvelope } from "./artifact-compatibility.js";
 //#region src/server/client-reuse-manifest.d.ts
-declare const CLIENT_REUSE_MANIFEST_SCHEMA_VERSION = 1;
+export declare const CLIENT_REUSE_MANIFEST_SCHEMA_VERSION = 1;
 type ClientReuseManifestSchemaVersion = 1;
-declare const CLIENT_REUSE_MANIFEST_HASH_ALGORITHM = "fnv1a64";
+export declare const CLIENT_REUSE_MANIFEST_HASH_ALGORITHM = "fnv1a64";
 type ClientReuseManifestHashAlgorithm = typeof CLIENT_REUSE_MANIFEST_HASH_ALGORITHM;
 type ClientReuseManifestLimits = Readonly<{
   maxEntryCount: number;
@@ -11,21 +11,21 @@ type ClientReuseManifestLimits = Readonly<{
   maxPayloadHashLength: number;
   maxVariantCacheKeyLength: number;
 }>;
-declare const DEFAULT_CLIENT_REUSE_MANIFEST_LIMITS: {
+export declare const DEFAULT_CLIENT_REUSE_MANIFEST_LIMITS: {
   maxEntryCount: number;
   maxEntryIdLength: number;
   maxManifestBytes: number;
   maxPayloadHashLength: number;
   maxVariantCacheKeyLength: number;
 };
-declare const CLIENT_REUSE_MANIFEST_SKIP_VERIFICATION_ENTRY_BUDGET = 8;
+export declare const CLIENT_REUSE_MANIFEST_SKIP_VERIFICATION_ENTRY_BUDGET = 8;
 type ClientReuseManifestEntryKind = "layout" | "page" | "route" | "slot" | "template";
 type ClientReuseManifestEntryPrivacy = "private" | "public";
 type ClientReuseManifestReplayWindow = Readonly<{
   validFromVisibleCommitVersion: number;
   validUntilVisibleCommitVersion: number;
 }>;
-type ClientReuseManifestEntry = Readonly<{
+export type ClientReuseManifestEntry = Readonly<{
   artifactCompatibility: ArtifactCompatibilityEnvelope;
   id: string;
   kind: ClientReuseManifestEntryKind;
@@ -59,17 +59,17 @@ type CreateClientReuseManifestInput = Readonly<{
   replayWindow?: ClientReuseManifestReplayWindow;
   visibleCommitVersion: number;
 }>;
-type ClientReuseManifestRejectionCode = "SKIP_CACHE_ARTIFACT_COMPATIBILITY_INCOMPATIBLE" | "SKIP_CACHE_ARTIFACT_COMPATIBILITY_UNKNOWN" | "SKIP_CACHE_ARTIFACT_PROOF_MISMATCH" | "SKIP_CACHE_ENTRY_ID_MISMATCH" | "SKIP_CACHE_INVALIDATED" | "SKIP_CACHE_INVALIDATION_UNKNOWN" | "SKIP_CACHE_PAYLOAD_HASH_MISMATCH" | "SKIP_CACHE_PAYLOAD_HASH_MISSING" | "SKIP_CACHE_PROOF_MISSING" | "SKIP_CACHE_PROOF_REJECTED" | "SKIP_CACHE_REUSE_CLASS_UNSUPPORTED" | "SKIP_CACHE_VARIANT_MISMATCH" | "SKIP_LAYOUT_CACHE_LIFE_OBSERVED" | "SKIP_LAYOUT_CACHE_TAGS_OBSERVED" | "SKIP_LAYOUT_CACHEABLE_FETCHES_OBSERVED" | "SKIP_LAYOUT_DYNAMIC_FETCHES_OBSERVED" | "SKIP_LAYOUT_DYNAMIC_USAGE_OBSERVED" | "SKIP_LAYOUT_PARAMS_OBSERVED" | "SKIP_LAYOUT_PARAMS_OBSERVATION_INCOMPLETE" | "SKIP_LAYOUT_PARAMS_PRESENT" | "SKIP_LAYOUT_REVALIDATE_PRESENT" | "SKIP_LAYOUT_REQUEST_API_OBSERVED" | "SKIP_LAYOUT_UNSTABLE_CACHE_OBSERVED" | "SKIP_ARTIFACT_COMPATIBILITY_INVALID" | "SKIP_ENTRY_COUNT_EXCEEDED" | "SKIP_VERIFICATION_BUDGET_EXCEEDED" | "SKIP_ENTRY_HASH_INVALID" | "SKIP_ENTRY_ID_INVALID" | "SKIP_ENTRY_ID_TOO_LONG" | "SKIP_ENTRY_MALFORMED" | "SKIP_ENTRY_ORDER_NON_CANONICAL" | "SKIP_HASH_ALGORITHM_UNSUPPORTED" | "SKIP_MANIFEST_MALFORMED" | "SKIP_MANIFEST_SCHEMA_UNSUPPORTED" | "SKIP_MANIFEST_TOO_LARGE" | "SKIP_PRIVATE_ENTRY" | "SKIP_REPLAY_WINDOW_INVALID" | "SKIP_UNKNOWN_ENTRY" | "SKIP_VARIANT_CACHE_KEY_INVALID" | "SKIP_VARIANT_CACHE_KEY_TOO_LONG" | "SKIP_VISIBLE_COMMIT_VERSION_INVALID" | "SKIP_VISIBLE_COMMIT_VERSION_MISMATCH";
+export type ClientReuseManifestRejectionCode = "SKIP_CACHE_ARTIFACT_COMPATIBILITY_INCOMPATIBLE" | "SKIP_CACHE_ARTIFACT_COMPATIBILITY_UNKNOWN" | "SKIP_CACHE_ARTIFACT_PROOF_MISMATCH" | "SKIP_CACHE_ENTRY_ID_MISMATCH" | "SKIP_CACHE_INVALIDATED" | "SKIP_CACHE_INVALIDATION_UNKNOWN" | "SKIP_CACHE_PAYLOAD_HASH_MISMATCH" | "SKIP_CACHE_PAYLOAD_HASH_MISSING" | "SKIP_CACHE_PROOF_MISSING" | "SKIP_CACHE_PROOF_REJECTED" | "SKIP_CACHE_REUSE_CLASS_UNSUPPORTED" | "SKIP_CACHE_VARIANT_MISMATCH" | "SKIP_LAYOUT_CACHE_LIFE_OBSERVED" | "SKIP_LAYOUT_CACHE_TAGS_OBSERVED" | "SKIP_LAYOUT_CACHEABLE_FETCHES_OBSERVED" | "SKIP_LAYOUT_DYNAMIC_FETCHES_OBSERVED" | "SKIP_LAYOUT_DYNAMIC_USAGE_OBSERVED" | "SKIP_LAYOUT_PARAMS_OBSERVED" | "SKIP_LAYOUT_PARAMS_OBSERVATION_INCOMPLETE" | "SKIP_LAYOUT_PARAMS_PRESENT" | "SKIP_LAYOUT_REVALIDATE_PRESENT" | "SKIP_LAYOUT_REQUEST_API_OBSERVED" | "SKIP_LAYOUT_UNSTABLE_CACHE_OBSERVED" | "SKIP_ARTIFACT_COMPATIBILITY_INVALID" | "SKIP_ENTRY_COUNT_EXCEEDED" | "SKIP_VERIFICATION_BUDGET_EXCEEDED" | "SKIP_ENTRY_HASH_INVALID" | "SKIP_ENTRY_ID_INVALID" | "SKIP_ENTRY_ID_TOO_LONG" | "SKIP_ENTRY_MALFORMED" | "SKIP_ENTRY_ORDER_NON_CANONICAL" | "SKIP_HASH_ALGORITHM_UNSUPPORTED" | "SKIP_MANIFEST_MALFORMED" | "SKIP_MANIFEST_SCHEMA_UNSUPPORTED" | "SKIP_MANIFEST_TOO_LARGE" | "SKIP_PRIVATE_ENTRY" | "SKIP_REPLAY_WINDOW_INVALID" | "SKIP_UNKNOWN_ENTRY" | "SKIP_VARIANT_CACHE_KEY_INVALID" | "SKIP_VARIANT_CACHE_KEY_TOO_LONG" | "SKIP_VISIBLE_COMMIT_VERSION_INVALID" | "SKIP_VISIBLE_COMMIT_VERSION_MISMATCH";
 type ClientReuseManifestTraceFieldValue = string | number | boolean | null | readonly string[];
-type ClientReuseManifestTraceFields = Readonly<Record<string, ClientReuseManifestTraceFieldValue>>;
-type ClientReuseManifestRejection = Readonly<{
+export type ClientReuseManifestTraceFields = Readonly<Record<string, ClientReuseManifestTraceFieldValue>>;
+export type ClientReuseManifestRejection = Readonly<{
   code: ClientReuseManifestRejectionCode;
   fields: ClientReuseManifestTraceFields;
 }>;
-type ClientReuseManifestEntryRejection = ClientReuseManifestRejection & Readonly<{
+export type ClientReuseManifestEntryRejection = ClientReuseManifestRejection & Readonly<{
   entryId: string | null;
 }>;
-type ClientReuseManifestSkipDisposition = Readonly<{
+export type ClientReuseManifestSkipDisposition = Readonly<{
   code: "SKIP_MODEL_DISABLED";
   enabled: false;
   mode: "renderAndSend";
@@ -79,7 +79,7 @@ type ClientReuseManifestSkipDisposition = Readonly<{
   mode: "skipStaticLayout";
   skippedEntryIds: readonly string[];
 }>;
-type ClientReuseManifestParseResult = Readonly<{
+export type ClientReuseManifestParseResult = Readonly<{
   kind: "absent";
 }> | Readonly<{
   kind: "rejected";
@@ -94,10 +94,9 @@ type ParseClientReuseManifestOptions = Readonly<{
   currentVisibleCommitVersion?: number;
   limits?: ClientReuseManifestLimits;
 }>;
-declare function countUtf8Bytes(input: string): number;
-declare function createClientReusePayloadHash(input: string): string;
-declare function createClientReuseManifest(input: CreateClientReuseManifestInput): ClientReuseManifestWire;
-declare function serializeClientReuseManifest(input: CreateClientReuseManifestInput): string;
-declare function parseClientReuseManifestHeader(rawHeader: string | null | undefined, options?: ParseClientReuseManifestOptions): ClientReuseManifestParseResult;
-//#endregion
-export { CLIENT_REUSE_MANIFEST_HASH_ALGORITHM, CLIENT_REUSE_MANIFEST_SCHEMA_VERSION, CLIENT_REUSE_MANIFEST_SKIP_VERIFICATION_ENTRY_BUDGET, ClientReuseManifestEntry, ClientReuseManifestEntryRejection, ClientReuseManifestParseResult, ClientReuseManifestRejection, ClientReuseManifestRejectionCode, ClientReuseManifestSkipDisposition, ClientReuseManifestTraceFields, DEFAULT_CLIENT_REUSE_MANIFEST_LIMITS, countUtf8Bytes, createClientReuseManifest, createClientReusePayloadHash, parseClientReuseManifestHeader, serializeClientReuseManifest };
+export declare function countUtf8Bytes(input: string): number;
+export declare function createClientReusePayloadHash(input: string): string;
+export declare function createClientReuseManifest(input: CreateClientReuseManifestInput): ClientReuseManifestWire;
+export declare function serializeClientReuseManifest(input: CreateClientReuseManifestInput): string;
+export declare function parseClientReuseManifestHeader(rawHeader: string | null | undefined, options?: ParseClientReuseManifestOptions): ClientReuseManifestParseResult;
+//#endregion

package/dist/server/client-reuse-manifest.js

@@ -1,7 +1,7 @@
 import { isUnknownRecord } from "../utils/record.js";
 import { fnv1a64 } from "../utils/hash.js";
+import { parseAppElementsWireElementKey } from "./app-elements-wire-key.js";
 import { parseArtifactCompatibilityEnvelope } from "./artifact-compatibility.js";
-import { AppElementsWire } from "./app-elements-wire.js";
 import { isNonNegativeSafeInteger } from "../utils/number.js";
 //#region src/server/client-reuse-manifest.ts
 const CLIENT_REUSE_MANIFEST_SCHEMA_VERSION = 1;
@@ -76,7 +76,7 @@ function currentCommitVersionMatchesReplayWindow(currentVisibleCommitVersion, re
 	return currentVisibleCommitVersion >= replayWindow.validFromVisibleCommitVersion && currentVisibleCommitVersion <= replayWindow.validUntilVisibleCommitVersion;
 }
 function parseEntryKind(id) {
-	const parsed = AppElementsWire.parseElementKey(id);
+	const parsed = parseAppElementsWireElementKey(id);
 	if (parsed === null) return null;
 	return parsed.kind;
 }