vinext 1.3.0 → 1.4.0

package/dist/server/cache-proof.js

@@ -1,16 +1,6 @@
 import { fnv1a64 } from "../utils/hash.js";
-import { evaluateArtifactCompatibility } from "./artifact-compatibility.js";
-import { findSortedStringPosition } from "../utils/sorted-array.js";
 //#region src/server/cache-proof.ts
 const CACHE_PROOF_MODEL_SCHEMA_VERSION = 1;
-const DEFAULT_CACHE_VARIANT_BUDGET = {
-	maxDimensionCount: 8,
-	maxDimensionNameLength: 64,
-	maxDimensionValueLength: 256,
-	maxEncodedLength: 1024,
-	maxValuesPerDimension: 8,
-	maxVariantsPerRoute: 64
-};
 const ALL_RENDER_REQUEST_API_KINDS = [
 	"connection",
 	"cookies",
@@ -19,13 +9,6 @@ const ALL_RENDER_REQUEST_API_KINDS = [
 	"params",
 	"searchParams"
 ];
-const PUBLIC_UNSAFE_DIMENSION_SOURCES = /* @__PURE__ */ new Set([
-	"auth",
-	"cookie",
-	"draft-mode",
-	"header",
-	"session"
-]);
 function buildBreakerFallback(code, fields = {}, mode = "renderFresh", scope = "affectedOutput") {
 	return {
 		kind: "breakerFallback",
@@ -38,332 +21,15 @@ function buildBreakerFallback(code, fields = {}, mode = "renderFresh", scope = "
 function sortedUnique(values) {
 	return [...new Set(values)].sort();
 }
-function normalizeDimensionName(name) {
-	return name.trim().toLowerCase();
-}
 function redactValue(value) {
 	return `h:${fnv1a64(value)}`;
 }
 function sortedUniqueRedacted(values) {
 	return sortedUnique(sortedUnique(values).map(redactValue));
 }
-function encodeParts(parts) {
-	return JSON.stringify(parts);
-}
-function compareDimensions(a, b) {
-	return a.source.localeCompare(b.source) || a.name.localeCompare(b.name) || a.privacy.localeCompare(b.privacy);
-}
-function encodeNullable(value) {
-	return value;
-}
 function assertNever(value) {
 	throw new Error(`Unhandled cache proof variant: ${String(value)}`);
 }
-function encodeOutputScope(output) {
-	switch (output.kind) {
-		case "app-html": return encodeParts([
-			output.kind,
-			output.routeId,
-			encodeNullable(output.rootBoundaryId),
-			encodeNullable(output.renderEpoch)
-		]);
-		case "app-rsc": return encodeParts([
-			output.kind,
-			output.routeId,
-			encodeNullable(output.rootBoundaryId),
-			encodeNullable(output.renderEpoch),
-			encodeNullable(output.mountedSlotsFingerprint)
-		]);
-		case "layout": return encodeParts([
-			output.kind,
-			output.routeId,
-			output.layoutId,
-			encodeNullable(output.rootBoundaryId)
-		]);
-		case "page": return encodeParts([
-			output.kind,
-			output.routeId,
-			output.pageId,
-			encodeNullable(output.rootBoundaryId)
-		]);
-		case "route-handler": return encodeParts([
-			output.kind,
-			output.routeId,
-			output.routeHandlerId
-		]);
-		case "slot": return encodeParts([
-			output.kind,
-			output.routeId,
-			output.slotId,
-			encodeNullable(output.rootBoundaryId)
-		]);
-		case "template": return encodeParts([
-			output.kind,
-			output.routeId,
-			output.templateId,
-			encodeNullable(output.rootBoundaryId)
-		]);
-		default: return assertNever(output);
-	}
-}
-function validateBudgetNumber(name, value) {
-	if (Number.isInteger(value) && value >= 0) return null;
-	return buildBreakerFallback("CP_INVALID_VARIANT_BUDGET", { budgetField: name });
-}
-function validateBudget(budget) {
-	return validateBudgetNumber("maxDimensionCount", budget.maxDimensionCount) ?? validateBudgetNumber("maxDimensionNameLength", budget.maxDimensionNameLength) ?? validateBudgetNumber("maxDimensionValueLength", budget.maxDimensionValueLength) ?? validateBudgetNumber("maxEncodedLength", budget.maxEncodedLength) ?? validateBudgetNumber("maxValuesPerDimension", budget.maxValuesPerDimension) ?? validateBudgetNumber("maxVariantsPerRoute", budget.maxVariantsPerRoute);
-}
-function buildDimension(input, budget) {
-	const name = normalizeDimensionName(input.name);
-	if (name.length === 0) return buildBreakerFallback("CP_DIMENSION_NAME_MISSING", { source: input.source });
-	if (name.length > budget.maxDimensionNameLength) return buildBreakerFallback("CP_DIMENSION_NAME_TOO_LONG", {
-		maxLength: budget.maxDimensionNameLength,
-		nameHash: redactValue(name),
-		source: input.source
-	});
-	if (input.privacy === "public" && PUBLIC_UNSAFE_DIMENSION_SOURCES.has(input.source)) return buildBreakerFallback("CP_UNSAFE_PUBLIC_DIMENSION", {
-		name,
-		source: input.source
-	}, "privateUncacheable");
-	const values = sortedUnique(input.values);
-	if (values.length === 0) return buildBreakerFallback("CP_DIMENSION_VALUES_MISSING", {
-		name,
-		source: input.source
-	});
-	if (values.length > budget.maxValuesPerDimension) return buildBreakerFallback("CP_DIMENSION_VALUE_COUNT_EXCEEDED", {
-		maxValues: budget.maxValuesPerDimension,
-		name,
-		source: input.source,
-		valueCount: values.length
-	});
-	for (const value of values) if (value.length > budget.maxDimensionValueLength) return buildBreakerFallback("CP_DIMENSION_VALUE_TOO_LONG", {
-		maxLength: budget.maxDimensionValueLength,
-		name,
-		source: input.source,
-		valueHash: redactValue(value)
-	});
-	const valueHashes = values.map(redactValue);
-	return {
-		encoded: encodeParts([
-			input.source,
-			input.privacy,
-			name,
-			valueHashes
-		]),
-		name,
-		privacy: input.privacy,
-		source: input.source,
-		valueCount: valueHashes.length,
-		valueHashes
-	};
-}
-function isCacheProofBreakerFallback(value) {
-	return "code" in value;
-}
-function getDimensionBucket(bySource, source, privacy) {
-	const existingByPrivacy = bySource.get(source);
-	const byPrivacy = existingByPrivacy ?? /* @__PURE__ */ new Map();
-	if (!existingByPrivacy) bySource.set(source, byPrivacy);
-	const existingByName = byPrivacy.get(privacy);
-	const byName = existingByName ?? /* @__PURE__ */ new Map();
-	if (!existingByName) byPrivacy.set(privacy, byName);
-	return byName;
-}
-function mergeDimensionInputs(dimensions) {
-	const bySource = /* @__PURE__ */ new Map();
-	const orderedDimensions = [];
-	for (const dimension of dimensions) {
-		const name = normalizeDimensionName(dimension.name);
-		const bucket = getDimensionBucket(bySource, dimension.source, dimension.privacy);
-		const existing = bucket.get(name);
-		if (existing) {
-			existing.values.push(...dimension.values);
-			continue;
-		}
-		const accumulator = {
-			name,
-			privacy: dimension.privacy,
-			source: dimension.source,
-			values: [...dimension.values]
-		};
-		bucket.set(name, accumulator);
-		orderedDimensions.push(accumulator);
-	}
-	return orderedDimensions;
-}
-function createAppRouteCacheProofGraphScope(route) {
-	return {
-		routeId: route.ids.route,
-		pageId: route.ids.page,
-		routeHandlerId: route.ids.routeHandler,
-		layoutIds: [...route.ids.layouts],
-		templateIds: [...route.ids.templates],
-		slotIds: sortedUnique(Object.values(route.ids.slots))
-	};
-}
-function buildCacheVariant(input) {
-	const budgetFallback = validateBudget(input.budget);
-	if (budgetFallback) return {
-		kind: "breakerFallback",
-		fallback: budgetFallback
-	};
-	const dimensionInputs = mergeDimensionInputs(input.dimensions);
-	if (dimensionInputs.length > input.budget.maxDimensionCount) return {
-		kind: "breakerFallback",
-		fallback: buildBreakerFallback("CP_DIMENSION_COUNT_EXCEEDED", {
-			dimensionCount: dimensionInputs.length,
-			maxDimensionCount: input.budget.maxDimensionCount,
-			routeId: input.output.routeId
-		})
-	};
-	const dimensions = [];
-	for (const dimensionInput of dimensionInputs) {
-		const dimension = buildDimension(dimensionInput, input.budget);
-		if (isCacheProofBreakerFallback(dimension)) return {
-			kind: "breakerFallback",
-			fallback: dimension
-		};
-		dimensions.push(dimension);
-	}
-	dimensions.sort(compareDimensions);
-	const encoded = [
-		`schema:1`,
-		encodeOutputScope(input.output),
-		...dimensions.map((dimension) => dimension.encoded)
-	].join("|");
-	if (encoded.length > input.budget.maxEncodedLength) return {
-		kind: "breakerFallback",
-		fallback: buildBreakerFallback("CP_ENCODED_VARIANT_TOO_LONG", {
-			encodedHash: redactValue(encoded),
-			encodedLength: encoded.length,
-			maxEncodedLength: input.budget.maxEncodedLength,
-			routeId: input.output.routeId
-		})
-	};
-	return {
-		kind: "variant",
-		variant: {
-			schemaVersion: 1,
-			cacheKey: `cp1:${fnv1a64(encoded)}`,
-			output: input.output,
-			dimensions,
-			encodedLength: encoded.length,
-			budget: { ...input.budget }
-		}
-	};
-}
-function normalizeRouteBudget(input) {
-	return {
-		routeId: input.routeId,
-		variantCacheKeys: sortedUnique(input.variantCacheKeys)
-	};
-}
-function buildRouteVariantCeilingFallback(variant, existingVariantCount) {
-	return buildBreakerFallback("CP_ROUTE_VARIANT_CEILING_EXCEEDED", {
-		existingVariantCount,
-		maxVariantsPerRoute: variant.budget.maxVariantsPerRoute,
-		routeId: variant.output.routeId
-	}, "privateUncacheable", "route");
-}
-function enforceCacheVariantRouteBudget(input) {
-	if (input.routeBudget && input.routeBudget.routeId !== input.variant.output.routeId) return {
-		kind: "breakerFallback",
-		routeBudget: normalizeRouteBudget(input.routeBudget),
-		fallback: buildBreakerFallback("CP_ROUTE_VARIANT_BUDGET_ROUTE_MISMATCH", {
-			budgetRouteId: input.routeBudget.routeId,
-			routeId: input.variant.output.routeId
-		}, "privateUncacheable", "route")
-	};
-	const routeBudget = normalizeRouteBudget(input.routeBudget ?? {
-		routeId: input.variant.output.routeId,
-		variantCacheKeys: []
-	});
-	const existingVariantCount = routeBudget.variantCacheKeys.length;
-	const variantKeyPosition = findSortedStringPosition(routeBudget.variantCacheKeys, input.variant.cacheKey);
-	if (existingVariantCount > input.variant.budget.maxVariantsPerRoute) return {
-		kind: "breakerFallback",
-		routeBudget,
-		fallback: buildRouteVariantCeilingFallback(input.variant, existingVariantCount)
-	};
-	if (variantKeyPosition.found) return {
-		kind: "variant",
-		variant: input.variant,
-		routeBudget,
-		didConsumeRouteVariantBudget: false
-	};
-	if (existingVariantCount >= input.variant.budget.maxVariantsPerRoute) return {
-		kind: "breakerFallback",
-		routeBudget,
-		fallback: buildRouteVariantCeilingFallback(input.variant, existingVariantCount)
-	};
-	return {
-		kind: "variant",
-		variant: input.variant,
-		routeBudget: {
-			routeId: routeBudget.routeId,
-			variantCacheKeys: [
-				...routeBudget.variantCacheKeys.slice(0, variantKeyPosition.index),
-				input.variant.cacheKey,
-				...routeBudget.variantCacheKeys.slice(variantKeyPosition.index)
-			]
-		},
-		didConsumeRouteVariantBudget: true
-	};
-}
-function buildCacheVariantWithRouteBudget(input) {
-	const variantResult = buildCacheVariant({
-		budget: input.budget,
-		dimensions: input.dimensions,
-		output: input.output
-	});
-	if (variantResult.kind === "breakerFallback") return {
-		kind: "breakerFallback",
-		routeBudget: input.routeBudget ? normalizeRouteBudget(input.routeBudget) : null,
-		fallback: variantResult.fallback
-	};
-	return enforceCacheVariantRouteBudget({
-		routeBudget: input.routeBudget,
-		variant: variantResult.variant
-	});
-}
-function boundaryOutcomesMatch(expected, candidate) {
-	switch (expected.kind) {
-		case "error": return candidate.kind === "error" && (expected.digest ?? "") === (candidate.digest ?? "");
-		case "forbidden": return candidate.kind === "forbidden";
-		case "globalError": return candidate.kind === "globalError" && (expected.digest ?? "") === (candidate.digest ?? "");
-		case "notFound": return candidate.kind === "notFound";
-		case "redirect": return candidate.kind === "redirect" && expected.status === candidate.status && expected.location === candidate.location;
-		case "success": return candidate.kind === "success";
-		case "unauthorized": return candidate.kind === "unauthorized";
-		case "unknown": return false;
-		default: return assertNever(expected);
-	}
-}
-function buildBoundaryOutcomeCompatibility(input) {
-	if (input.expected.kind === "unknown" || input.candidate.kind === "unknown") return {
-		kind: "incompatible",
-		expected: input.expected,
-		candidate: input.candidate,
-		fallback: buildBreakerFallback("CP_BOUNDARY_OUTCOME_UNKNOWN", {
-			candidateKind: input.candidate.kind,
-			expectedKind: input.expected.kind
-		})
-	};
-	if (boundaryOutcomesMatch(input.expected, input.candidate)) return {
-		kind: "compatible",
-		outcome: input.candidate,
-		reason: "CP_BOUNDARY_OUTCOME_MATCH"
-	};
-	return {
-		kind: "incompatible",
-		expected: input.expected,
-		candidate: input.candidate,
-		fallback: buildBreakerFallback("CP_BOUNDARY_OUTCOME_MISMATCH", {
-			candidateKind: input.candidate.kind,
-			expectedKind: input.expected.kind
-		})
-	};
-}
 function requestApiStatusRank(status) {
 	switch (status) {
 		case "notObserved": return 0;
@@ -447,47 +113,6 @@ function classifyObservedRequestApiDowngrade(kind) {
 		default: return assertNever(kind);
 	}
 }
-function classifyCacheVariantDimensionDowngrade(input) {
-	switch (input.source) {
-		case "auth": return {
-			code: "CP_DOWNGRADE_PRIVATE_DIMENSION",
-			inputClass: "auth",
-			source: "auth",
-			target: "private"
-		};
-		case "cookie": return {
-			code: "CP_DOWNGRADE_PRIVATE_DIMENSION",
-			inputClass: "private",
-			source: "cookie",
-			target: "private"
-		};
-		case "draft-mode": return {
-			code: "CP_DOWNGRADE_PRIVATE_DIMENSION",
-			inputClass: "draft",
-			source: "draft-mode",
-			target: "privateUncacheable"
-		};
-		case "header": return {
-			code: "CP_DOWNGRADE_PRIVATE_DIMENSION",
-			inputClass: "private",
-			source: "header",
-			target: "private"
-		};
-		case "session": return {
-			code: "CP_DOWNGRADE_PRIVATE_DIMENSION",
-			inputClass: "session",
-			source: "session",
-			target: "private"
-		};
-		case "custom":
-		case "interception":
-		case "mounted-slots":
-		case "params":
-		case "route":
-		case "search": return null;
-		default: return assertNever(input.source);
-	}
-}
 function classifyRenderObservationDowngrade(input) {
 	const reasons = [];
 	let target = "public";
@@ -602,164 +227,6 @@ function hasCompleteNegativeRequestApiProof(observation, requiredApis) {
 function hasQueryInvariantRenderProof(observation) {
 	return observation !== void 0 && hasCompleteNegativeRequestApiProof(observation, ["searchParams"]);
 }
-function isStaticLayoutOutputScope(output) {
-	return output.kind === "layout";
-}
-function rejectStaticLayoutReuseProof(code, fields, mode = "renderFresh") {
-	return {
-		kind: "rejected",
-		fallback: buildBreakerFallback(code, fields, mode)
-	};
-}
-function getRequestApiStatus(observations, kind) {
-	let status = null;
-	for (const requestApi of observations) {
-		if (requestApi.kind !== kind) continue;
-		if (status === null || requestApiStatusRank(requestApi.status) > requestApiStatusRank(status)) status = requestApi.status;
-	}
-	return status ?? "missing";
-}
-function createStaticLayoutDowngradeFallback(downgrade) {
-	const mode = downgrade.target === "privateUncacheable" ? "privateUncacheable" : "renderFresh";
-	return buildBreakerFallback("CP_STATIC_LAYOUT_PRIVATE_DYNAMIC_DOWNGRADE", {
-		reasonCodes: downgrade.reasons.map((reason) => reason.code),
-		target: downgrade.target
-	}, mode);
-}
-function outputFieldMismatch(candidate, observation) {
-	if (candidate.layoutId !== observation.layoutId) return "layoutId";
-	if (candidate.rootBoundaryId !== observation.rootBoundaryId) return "rootBoundaryId";
-	if (candidate.routeId !== observation.routeId) return "routeId";
-	return null;
-}
-function buildStaticLayoutReuseProof(input) {
-	if (!isStaticLayoutOutputScope(input.currentOutput)) return rejectStaticLayoutReuseProof("CP_STATIC_LAYOUT_CURRENT_OUTPUT_KIND", { currentOutputKind: input.currentOutput.kind });
-	if (!isStaticLayoutOutputScope(input.candidateVariant.output)) return rejectStaticLayoutReuseProof("CP_STATIC_LAYOUT_CANDIDATE_OUTPUT_KIND", { candidateOutputKind: input.candidateVariant.output.kind });
-	if (!isStaticLayoutOutputScope(input.candidateObservation.output)) return rejectStaticLayoutReuseProof("CP_STATIC_LAYOUT_OBSERVATION_OUTPUT_KIND", { observationOutputKind: input.candidateObservation.output.kind });
-	const currentOutput = input.currentOutput;
-	const candidateOutput = input.candidateVariant.output;
-	const observationOutput = input.candidateObservation.output;
-	const requestApis = normalizeRequestApiObservations(input.candidateObservation.requestApis);
-	const candidateObservation = {
-		...input.candidateObservation,
-		requestApis,
-		downgrade: classifyRenderObservationDowngrade({
-			cacheability: input.candidateObservation.cacheability,
-			completeness: input.candidateObservation.completeness,
-			dynamicFetches: input.candidateObservation.dynamicFetches,
-			requestApis
-		})
-	};
-	const observedOutputMismatch = outputFieldMismatch(candidateOutput, observationOutput);
-	if (observedOutputMismatch) return rejectStaticLayoutReuseProof("CP_STATIC_LAYOUT_OBSERVATION_OUTPUT_MISMATCH", {
-		candidateLayoutId: candidateOutput.layoutId,
-		candidateRootBoundaryId: candidateOutput.rootBoundaryId,
-		candidateRouteId: candidateOutput.routeId,
-		field: observedOutputMismatch,
-		observationLayoutId: observationOutput.layoutId,
-		observationRootBoundaryId: observationOutput.rootBoundaryId,
-		observationRouteId: observationOutput.routeId
-	});
-	if (currentOutput.layoutId !== candidateOutput.layoutId) return rejectStaticLayoutReuseProof("CP_STATIC_LAYOUT_ID_MISMATCH", {
-		candidateLayoutId: candidateOutput.layoutId,
-		currentLayoutId: currentOutput.layoutId
-	});
-	if (currentOutput.rootBoundaryId === null || candidateOutput.rootBoundaryId === null) return rejectStaticLayoutReuseProof("CP_STATIC_LAYOUT_ROOT_BOUNDARY_UNKNOWN", {
-		candidateRootBoundaryId: candidateOutput.rootBoundaryId,
-		currentRootBoundaryId: currentOutput.rootBoundaryId
-	});
-	if (currentOutput.rootBoundaryId !== candidateOutput.rootBoundaryId) return rejectStaticLayoutReuseProof("CP_STATIC_LAYOUT_ROOT_BOUNDARY_MISMATCH", {
-		candidateRootBoundaryId: candidateOutput.rootBoundaryId,
-		currentRootBoundaryId: currentOutput.rootBoundaryId
-	});
-	const boundaryCompatibility = buildBoundaryOutcomeCompatibility({
-		candidate: candidateObservation.boundaryOutcome,
-		expected: { kind: "success" }
-	});
-	if (boundaryCompatibility.kind === "incompatible") return {
-		kind: "rejected",
-		fallback: boundaryCompatibility.fallback
-	};
-	if (input.candidateVariant.dimensions.length > 0) return rejectStaticLayoutReuseProof("CP_STATIC_LAYOUT_VARIANT_DIMENSION_UNPROVEN", {
-		dimensionCount: input.candidateVariant.dimensions.length,
-		sources: sortedUnique(input.candidateVariant.dimensions.map((dimension) => dimension.source))
-	});
-	if (!candidateObservation.downgrade.isPublicCacheCandidate) return {
-		kind: "rejected",
-		fallback: createStaticLayoutDowngradeFallback(candidateObservation.downgrade)
-	};
-	const requiredNegativeRequestApis = ALL_RENDER_REQUEST_API_KINDS;
-	for (const api of requiredNegativeRequestApis) {
-		const status = getRequestApiStatus(candidateObservation.requestApis, api);
-		if (status === "notObserved") continue;
-		return rejectStaticLayoutReuseProof(status === "missing" ? "CP_STATIC_LAYOUT_REQUEST_API_UNKNOWN" : "CP_STATIC_LAYOUT_REQUEST_API_OBSERVED", {
-			requestApi: api,
-			status
-		});
-	}
-	return {
-		kind: "proof",
-		proof: {
-			authorizesRuntimeReuse: true,
-			candidateOutput,
-			code: "CP_STATIC_LAYOUT_REUSE_PROVEN",
-			currentOutput,
-			fields: {
-				candidateRouteId: candidateOutput.routeId,
-				currentRouteId: currentOutput.routeId,
-				layoutId: currentOutput.layoutId,
-				rootBoundaryId: currentOutput.rootBoundaryId
-			},
-			observation: candidateObservation,
-			requiredNegativeRequestApis: [...requiredNegativeRequestApis],
-			reuseClass: "static-layout",
-			variant: input.candidateVariant
-		}
-	};
-}
-function createCacheProofHotPathMetric(outcome, code, fields) {
-	return {
-		name: "vinext.cache.static_layout_artifact_reuse",
-		outcome,
-		code,
-		fields
-	};
-}
-function createStaticLayoutArtifactReuseFallback(fallback) {
-	return {
-		kind: "fallback",
-		canReuse: false,
-		fallback,
-		metric: createCacheProofHotPathMetric("fallback", fallback.code, fallback.fields)
-	};
-}
-function createStaticLayoutArtifactReuseDecision(input) {
-	if (input.candidateVariant.kind === "breakerFallback") return createStaticLayoutArtifactReuseFallback(input.candidateVariant.fallback);
-	const artifactCompatibility = evaluateArtifactCompatibility(input.currentArtifactCompatibility, input.candidateArtifactCompatibility, { compatibilityMap: input.compatibilityMap });
-	if (artifactCompatibility.kind === "unknown") return createStaticLayoutArtifactReuseFallback(buildBreakerFallback("CP_ARTIFACT_COMPATIBILITY_UNKNOWN", {
-		compatibilityFallback: artifactCompatibility.fallback,
-		reason: artifactCompatibility.reason
-	}));
-	if (artifactCompatibility.kind === "incompatible") return createStaticLayoutArtifactReuseFallback(buildBreakerFallback("CP_ARTIFACT_COMPATIBILITY_INCOMPATIBLE", {
-		compatibilityFallback: artifactCompatibility.fallback,
-		reason: artifactCompatibility.reason
-	}));
-	const proof = buildStaticLayoutReuseProof({
-		candidateObservation: input.candidateObservation,
-		candidateVariant: input.candidateVariant.variant,
-		currentOutput: input.currentOutput
-	});
-	if (proof.kind === "rejected") return createStaticLayoutArtifactReuseFallback(proof.fallback);
-	return {
-		kind: "reuse",
-		canReuse: true,
-		proof: {
-			...proof.proof,
-			candidateArtifactCompatibility: { ...input.candidateArtifactCompatibility }
-		},
-		metric: createCacheProofHotPathMetric("reuse", proof.proof.code, proof.proof.fields)
-	};
-}
 function createCacheEntryReuseProof(decision) {
 	if (decision === null) return {
 		kind: "runtime-cache-entry",
@@ -788,15 +255,5 @@ function createCacheEntryReuseProof(decision) {
 		default: return assertNever(decision);
 	}
 }
-function createDisabledCacheProofDecision(input) {
-	return {
-		kind: "disabled",
-		canReuse: false,
-		variant: input.variant,
-		observation: input.observation,
-		...input.staticLayoutProof ? { staticLayoutProof: input.staticLayoutProof } : {},
-		fallback: buildBreakerFallback("CP_MODEL_DISABLED")
-	};
-}
 //#endregion
-export { ALL_RENDER_REQUEST_API_KINDS, CACHE_PROOF_MODEL_SCHEMA_VERSION, DEFAULT_CACHE_VARIANT_BUDGET, buildBoundaryOutcomeCompatibility, buildCacheVariant, buildCacheVariantWithRouteBudget, buildRenderObservation, buildRenderRequestApiObservations, buildStaticLayoutReuseProof, classifyCacheVariantDimensionDowngrade, classifyRenderObservationDowngrade, createAppRouteCacheProofGraphScope, createCacheEntryReuseProof, createDisabledCacheProofDecision, createStaticLayoutArtifactReuseDecision, enforceCacheVariantRouteBudget, hasCompleteNegativeRequestApiProof, hasQueryInvariantRenderProof };
+export { ALL_RENDER_REQUEST_API_KINDS, CACHE_PROOF_MODEL_SCHEMA_VERSION, buildRenderObservation, buildRenderRequestApiObservations, classifyRenderObservationDowngrade, createCacheEntryReuseProof, hasCompleteNegativeRequestApiProof, hasQueryInvariantRenderProof };

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

@@ -46,4 +46,5 @@ export type CacheabilityAdmissionCaptureBudget = {
 export declare function createCacheabilityAdmissionCaptureBudget(maxBytes: number): CacheabilityAdmissionCaptureBudget;
 export declare function captureCacheabilityAdmissionBody(body: ReadableStream<Uint8Array> | null, deadlineAt: number, limit?: number, budget?: CacheabilityAdmissionCaptureBudget): Promise<CapturedAdmissionBody>;
 export declare function finalizeWorkerCacheabilityResponse(response: Response, ctx: ExecutionContextLike): Promise<Response>;
-//#endregion
+//#endregion
+export {};

package/dist/server/cacheability-request.js

@@ -1,6 +1,6 @@
 import "../utils/protocol-headers.js";
 import { isVinextRscVaryField } from "./app-rsc-vary.js";
-import { VINEXT_CACHEABILITY_PROBE_HEADER, VINEXT_CACHEABILITY_PROBE_ROUTE_HEADER, VINEXT_SPECIAL_ERROR_STATUS_HEADER } from "./headers.js";
+import { NEXT_ROUTER_STALE_TIME_HEADER, VINEXT_CACHEABILITY_PROBE_HEADER, VINEXT_CACHEABILITY_PROBE_ROUTE_HEADER, VINEXT_SPECIAL_ERROR_STATUS_HEADER, VINEXT_STALE_TIME_PENDING_HEADER } from "./headers.js";
 import { hasSharedCacheCredentials, 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";
@@ -348,20 +348,25 @@ async function captureCacheabilityAdmissionBody(body, deadlineAt, limit = CACHEA
 		throw error;
 	}
 }
-function responseWithCachePolicy(response, body, outcome, browserCacheControl, completedStatus) {
+function responseWithCachePolicy(response, body, outcome, browserCacheControl, completedRender) {
 	const headers = new Headers(response.headers);
 	if (typeof body === "string") headers.delete("Content-Length");
-	for (const [name, value] of Object.entries(completedStatus?.headers ?? {})) if (!headers.has(name)) headers.set(name, value);
-	applyCdnResponseHeaders(headers, outcome?.cacheable === true && outcome.cacheControl ? {
-		cacheControl: outcome.cacheControl,
-		tags: outcome.tags,
+	for (const [name, value] of Object.entries(completedRender?.headers ?? {})) if (!headers.has(name)) headers.set(name, value);
+	const cacheControl = outcome?.cacheable === true ? outcome.cacheControl : void 0;
+	applyCdnResponseHeaders(headers, cacheControl ? {
+		cacheControl,
+		tags: outcome?.tags,
 		browserCacheControl
 	} : {
 		cacheControl: NO_STORE_CACHE_CONTROL,
 		browserCacheControl
 	});
-	const status = completedStatus?.status ?? response.status;
-	const completed = completedStatus?.status;
+	if (cacheControl && completedRender) {
+		headers.delete(VINEXT_STALE_TIME_PENDING_HEADER);
+		if (completedRender.staleTimeSeconds !== void 0 && !headers.has("x-nextjs-stale-time")) headers.set(NEXT_ROUTER_STALE_TIME_HEADER, String(Math.floor(completedRender.staleTimeSeconds)));
+	}
+	const status = completedRender?.status ?? response.status;
+	const completed = completedRender?.status;
 	if (completed === 401 || completed === 403 || completed === 404) headers.set(VINEXT_SPECIAL_ERROR_STATUS_HEADER, String(completed));
 	return new Response(body, {
 		headers,

package/dist/server/config-headers.d.ts

@@ -39,4 +39,5 @@ type ApplyConfigHeadersOptions = {
 export declare function applyConfigHeadersToResponse(responseHeaders: Headers, options: ApplyConfigHeadersOptions): void;
 /** Apply matched next.config.js headers to an early response header record. */
 export declare function applyConfigHeadersToHeaderRecord(headers: HeaderRecord, options: ApplyConfigHeadersOptions): void;
-//#endregion
+//#endregion
+export {};

package/dist/server/csp.d.ts

@@ -5,4 +5,5 @@ export declare function getScriptNonceFromHeader(cspHeaderValue: string): string
 export declare function getScriptNonceFromHeaders(headers: Headers | null | undefined): string | undefined;
 export declare function getScriptNonceFromNodeHeaderSources(...headersList: readonly (NodeHeaders | null | undefined)[]): string | undefined;
 export declare function getScriptNonceFromHeaderSources(...headersList: readonly (Headers | null | undefined)[]): string | undefined;
-//#endregion
+//#endregion
+export {};

package/dist/server/default-global-not-found-module.d.ts

@@ -9,4 +9,5 @@ declare function DefaultGlobalNotFound(): React.ReactElement;
 export declare const DEFAULT_GLOBAL_NOT_FOUND_MODULE: {
   readonly default: typeof DefaultGlobalNotFound;
 };
-//#endregion
+//#endregion
+export {};