@vinext/cloudflare 1.0.0-beta.1 → 1.0.0-beta.10

package/dist/cacheability-probe.js

@@ -0,0 +1,660 @@
+import { MAX_CACHEABILITY_MANIFEST_BYTES, cacheabilityManifestByteLimitError } from "./cacheability-manifest-limits.js";
+import "./cache/cdn-build-id.js";
+import fs from "node:fs";
+import path from "node:path";
+import { Buffer } from "node:buffer";
+import { cacheabilityManifestRouteKey, cacheabilityRequestIdentity, cacheabilityRoutePathname, normalizeCacheabilityRoutePathname } from "vinext/internal/server/cacheability-manifest";
+import { randomUUID } from "node:crypto";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+import { VINEXT_CACHEABILITY_PROBE_HEADER, VINEXT_CACHEABILITY_PROBE_QUERY_PARAM, VINEXT_CACHEABILITY_PROBE_ROUTE_HEADER, VINEXT_PRERENDER_SECRET_HEADER } from "vinext/internal/server/headers";
+//#region src/cacheability-probe.ts
+const DEFAULT_CACHEABILITY_PROBE_PHASE_TIMEOUT_MS = 12e4;
+const DEFAULT_CACHEABILITY_PROBE_RETRIES = 2;
+const DEFAULT_CACHEABILITY_PROBE_RETRY_DELAY_MS = 1e3;
+const DEFAULT_CACHEABILITY_PROBE_REQUEST_TIMEOUT_MS = 3e4;
+const MAX_CACHEABILITY_PROBE_ENVELOPE_BYTES = 65536;
+function sharedPathPrefix(pathnames) {
+	if (pathnames.length === 0) return null;
+	let prefix = pathnames[0];
+	for (const pathname of pathnames.slice(1)) {
+		const limit = Math.min(prefix.length, pathname.length);
+		let length = 0;
+		while (length < limit && prefix.charCodeAt(length) === pathname.charCodeAt(length)) length++;
+		prefix = prefix.slice(0, length);
+	}
+	while (prefix.length > 1 && pathnames.some((pathname) => pathname !== prefix && (prefix.endsWith("/") ? !pathname.startsWith(prefix) : !pathname.startsWith(`${prefix}/`)))) {
+		const slash = prefix.lastIndexOf("/");
+		prefix = slash <= 0 ? "/" : prefix.slice(0, slash + 1);
+	}
+	return prefix || null;
+}
+/** Remove a shared pathname prefix only when it makes the serialized route smaller. */
+function compactManifestRoutePaths(route) {
+	const pathPrefix = sharedPathPrefix([...route.runtimePaths ?? [], ...Object.values(route.staticPaths ?? {}).flatMap((paths) => paths ?? [])]);
+	if (!pathPrefix) return route;
+	const compacted = {
+		...route,
+		pathPrefix,
+		...route.runtimePaths ? { runtimePaths: route.runtimePaths.map((pathname) => pathname.slice(pathPrefix.length)) } : {},
+		...route.staticPaths ? { staticPaths: Object.fromEntries(Object.entries(route.staticPaths).map(([representation, paths]) => [representation, paths.map((pathname) => pathname.slice(pathPrefix.length))])) } : {}
+	};
+	return Buffer.byteLength(JSON.stringify(compacted)) < Buffer.byteLength(JSON.stringify(route)) ? compacted : route;
+}
+function isProbeRouteState(value) {
+	return value === "static-candidate" || value === "dynamic" || value === "probe-failed";
+}
+function isRetryableProbeHttpStatus(status) {
+	return status === 404 || status === 408 || status === 429 || status >= 502;
+}
+function readPrerenderSecret(root) {
+	const manifestPath = path.join(root, "dist", "server", "vinext-server.json");
+	const parsed = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+	const secret = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed.prerenderSecret : void 0;
+	if (typeof secret !== "string" || secret.length === 0) throw new Error("Cannot probe staged Worker cacheability because dist/server/vinext-server.json does not contain a prerender secret. Rebuild the app before deploying.");
+	return secret;
+}
+async function readProbeEnvelope(response) {
+	if (!response.body) throw new Error("probe returned invalid JSON");
+	const reader = response.body.getReader();
+	const chunks = [];
+	let bytes = 0;
+	try {
+		while (true) {
+			const result = await reader.read();
+			if (result.done) break;
+			bytes += result.value.byteLength;
+			if (bytes > MAX_CACHEABILITY_PROBE_ENVELOPE_BYTES) {
+				await reader.cancel().catch(() => {});
+				return {
+					reason: `probe response exceeded ${MAX_CACHEABILITY_PROBE_ENVELOPE_BYTES} bytes`,
+					state: "probe-failed",
+					version: 1
+				};
+			}
+			chunks.push(result.value);
+		}
+	} finally {
+		reader.releaseLock();
+	}
+	try {
+		return JSON.parse(Buffer.concat(chunks, bytes).toString("utf8"));
+	} catch {
+		throw new Error("probe returned invalid JSON");
+	}
+}
+async function probeTarget(options) {
+	const headers = new Headers(options.headers);
+	for (const [name, value] of new Headers(options.target.headers)) headers.set(name, value);
+	headers.set(VINEXT_CACHEABILITY_PROBE_HEADER, "1");
+	if (options.target.route) headers.set(VINEXT_CACHEABILITY_PROBE_ROUTE_HEADER, encodeURIComponent(JSON.stringify([options.target.route.kind, options.target.route.pattern])));
+	headers.set(VINEXT_PRERENDER_SECRET_HEADER, options.secret);
+	let reason = "probe failed";
+	const probeId = randomUUID();
+	const phaseTimeoutPayload = () => ({
+		phaseTimedOut: true,
+		reason: `cacheability probing made no progress for ${options.phaseTimeoutMs}ms`,
+		state: "probe-failed",
+		version: 1
+	});
+	let ordinaryFailures = 0;
+	let retryable = true;
+	for (let attempt = 0;; attempt++) {
+		if (options.getDeadlineAt() - Date.now() <= 0) return phaseTimeoutPayload();
+		retryable = true;
+		const controller = new AbortController();
+		const requestDeadlineAt = Date.now() + options.timeoutMs;
+		let timeout;
+		let timedOutBy = null;
+		let retryUntilDeadline = false;
+		try {
+			const url = new URL(options.target.pathname, options.targetUrl);
+			url.searchParams.set(VINEXT_CACHEABILITY_PROBE_QUERY_PARAM, `${probeId}-${attempt}`);
+			const request = (async () => {
+				const response = await options.fetchImpl(url, {
+					headers,
+					redirect: "manual",
+					signal: controller.signal
+				});
+				if (options.expectedBuildId !== void 0 && response.headers.get("X-Vinext-Build-Id") !== options.expectedBuildId) {
+					response.body?.cancel().catch(() => {});
+					return {
+						kind: "retry",
+						reason: "probe reached an unexpected Worker build",
+						retryable: true,
+						retryUntilDeadline: true
+					};
+				}
+				if (!response.ok) {
+					response.body?.cancel().catch(() => {});
+					return {
+						kind: "retry",
+						reason: `probe returned HTTP ${response.status}`,
+						retryable: isRetryableProbeHttpStatus(response.status),
+						retryUntilDeadline: false
+					};
+				}
+				const payload = await readProbeEnvelope(response);
+				if (payload.state === "probe-failed" && payload.retryable === true) return {
+					kind: "retry",
+					reason: payload.reason ?? "probe failed",
+					retryable: true,
+					retryUntilDeadline: false
+				};
+				return {
+					kind: "complete",
+					payload
+				};
+			})();
+			const timedOut = new Promise((_resolve, reject) => {
+				const checkDeadline = () => {
+					const phaseDeadlineAt = options.getDeadlineAt();
+					const remainingMs = Math.min(requestDeadlineAt, phaseDeadlineAt) - Date.now();
+					if (remainingMs > 0) {
+						timeout = setTimeout(checkDeadline, remainingMs);
+						return;
+					}
+					timedOutBy = requestDeadlineAt <= phaseDeadlineAt ? "request" : "phase";
+					controller.abort();
+					reject(new DOMException("Probe deadline exceeded", "AbortError"));
+				};
+				checkDeadline();
+			});
+			const result = await Promise.race([request, timedOut]);
+			if (Date.now() >= options.getDeadlineAt()) return phaseTimeoutPayload();
+			if (result.kind === "complete") return result.payload;
+			reason = result.reason;
+			retryable = result.retryable;
+			retryUntilDeadline = result.retryUntilDeadline;
+		} catch (error) {
+			if (timedOutBy === "phase" || Date.now() >= options.getDeadlineAt()) return phaseTimeoutPayload();
+			reason = error instanceof Error && error.name === "AbortError" ? `probe timed out after ${options.timeoutMs}ms` : error instanceof Error ? error.message : String(error);
+		} finally {
+			if (timeout !== void 0) clearTimeout(timeout);
+		}
+		if (!retryable) break;
+		if (!retryUntilDeadline && ++ordinaryFailures > options.retries) break;
+		if (options.retryDelayMs > 0) {
+			const delayMs = Math.min(options.retryDelayMs, Math.max(0, options.getDeadlineAt() - Date.now()));
+			if (delayMs <= 0) return phaseTimeoutPayload();
+			await setTimeout$1(delayMs);
+		}
+	}
+	return {
+		reason,
+		...retryable ? { retryable: true } : {},
+		state: "probe-failed",
+		version: 1
+	};
+}
+async function probeStagedWorkerCacheability(options) {
+	const secret = readPrerenderSecret(options.root);
+	const concurrency = Math.max(1, options.concurrency ?? 25);
+	const retries = Math.max(0, options.retries ?? 2);
+	const retryDelayMs = Math.max(0, options.retryDelayMs ?? 1e3);
+	const timeoutMs = Math.max(1, options.timeoutMs ?? DEFAULT_CACHEABILITY_PROBE_REQUEST_TIMEOUT_MS);
+	const phaseTimeoutMs = Math.max(1, options.phaseTimeoutMs ?? 12e4);
+	let lastProgressAt = Date.now();
+	const getDeadlineAt = () => lastProgressAt + phaseTimeoutMs;
+	const routes = {};
+	const cacheableTargets = [];
+	const speculativeTargets = [];
+	const failures = [];
+	const maxManifestBytes = Math.min(options.manifestLimits?.maxBytes ?? 2097152, MAX_CACHEABILITY_MANIFEST_BYTES);
+	const emptyManifest = {
+		buildId: options.buildId,
+		routes: {},
+		version: 1
+	};
+	let manifestBytes = Buffer.byteLength(JSON.stringify(emptyManifest));
+	const routeEntryBytes = /* @__PURE__ */ new Map();
+	let limitFailure = null;
+	let phaseTimedOut = false;
+	let probed = 0;
+	let completedPathCount = 0;
+	let skippedPathCount = 0;
+	let staticPathCount = 0;
+	let dynamicPathCount = 0;
+	const targetPreference = (target) => {
+		if (target.route?.kind === "app-route") return target.kind === "app-route" ? 0 : 1;
+		return target.kind === "html" ? 0 : target.kind === "rsc-full" ? 1 : 2;
+	};
+	const patterns = /* @__PURE__ */ new Map();
+	const routableTargets = [];
+	let missingRouteMetadata = 0;
+	for (const target of options.targets) {
+		if (!target.route) {
+			missingRouteMetadata++;
+			continue;
+		}
+		const key = cacheabilityManifestRouteKey(target.route.kind, target.route.pattern);
+		const pattern = patterns.get(key) ?? {
+			canPrune: true,
+			groups: [],
+			key,
+			resultKeys: /* @__PURE__ */ new Set(),
+			pruned: false,
+			results: /* @__PURE__ */ new Map(),
+			route: target.route,
+			requestStageMayTerminate: false
+		};
+		pattern.requestStageMayTerminate ||= target.route.cacheabilityProbe?.requestStageMayTerminate === true;
+		pattern.canPrune &&= target.route.cacheabilityProbe?.canPrunePattern === true && target.route.cacheabilityProbe.routeMayResolve !== true && target.route.cacheabilityProbe.requestStageMayTerminate !== true;
+		patterns.set(key, pattern);
+		routableTargets.push(target);
+	}
+	if (missingRouteMetadata > 0) failures.push(`${missingRouteMetadata} warm target${missingRouteMetadata === 1 ? " is" : "s are"} missing route-pattern metadata`);
+	const targetGroups = /* @__PURE__ */ new Map();
+	for (const target of routableTargets) {
+		const route = target.route;
+		const key = cacheabilityManifestRouteKey(route.kind, route.pattern);
+		const pattern = patterns.get(key);
+		const routePathname = route.cacheabilityProbe?.concretePathname ?? cacheabilityRoutePathname(target.pathname, target.kind);
+		const resultKey = routePathname;
+		pattern.resultKeys.add(resultKey);
+		const concreteKey = `${key}\0${resultKey}`;
+		const group = targetGroups.get(concreteKey) ?? {
+			pattern,
+			resultKey,
+			routePathname,
+			targets: []
+		};
+		group.targets.push(target);
+		targetGroups.set(concreteKey, group);
+	}
+	const groups = Array.from(targetGroups.values(), (targetGroup) => {
+		targetGroup.targets.sort((first, second) => {
+			return targetPreference(first) - targetPreference(second) || first.sourcePathname.localeCompare(second.sourcePathname);
+		});
+		const group = {
+			...targetGroup,
+			deferred: false,
+			primary: targetGroup.targets[0]
+		};
+		targetGroup.pattern.groups.push(group);
+		return group;
+	});
+	const reportProgress = () => {
+		options.onProgress?.({
+			completed: completedPathCount + (missingRouteMetadata > 0 ? 1 : 0),
+			dynamic: dynamicPathCount,
+			failed: failures.length,
+			probed,
+			skipped: skippedPathCount,
+			static: staticPathCount,
+			total: groups.length + (missingRouteMetadata > 0 ? 1 : 0)
+		});
+	};
+	const addRouteWithinManifestLimits = (key, route) => {
+		const previousBytes = routeEntryBytes.get(key);
+		const nextEntryBytes = Buffer.byteLength(`${JSON.stringify(key)}:${JSON.stringify(route)}`);
+		const nextManifestBytes = previousBytes === void 0 ? manifestBytes + nextEntryBytes + (routeEntryBytes.size > 0 ? 1 : 0) : manifestBytes - previousBytes + nextEntryBytes;
+		if (nextManifestBytes > maxManifestBytes) {
+			limitFailure = cacheabilityManifestByteLimitError(nextManifestBytes, maxManifestBytes);
+			return false;
+		}
+		routes[key] = route;
+		routeEntryBytes.set(key, nextEntryBytes);
+		manifestBytes = nextManifestBytes;
+		return true;
+	};
+	const moveGroupToResolvedRoute = (group, route) => {
+		const previousPattern = group.pattern;
+		const key = cacheabilityManifestRouteKey(route.kind, route.pattern);
+		let pattern = patterns.get(key);
+		if (!pattern) {
+			pattern = {
+				canPrune: false,
+				groups: [],
+				key,
+				resultKeys: /* @__PURE__ */ new Set(),
+				pruned: false,
+				results: /* @__PURE__ */ new Map(),
+				route,
+				requestStageMayTerminate: previousPattern.requestStageMayTerminate
+			};
+			patterns.set(key, pattern);
+		}
+		pattern.canPrune = false;
+		pattern.requestStageMayTerminate ||= previousPattern.requestStageMayTerminate;
+		pattern.pruned = false;
+		if (pattern === previousPattern) return pattern;
+		const previousGroupIndex = previousPattern.groups.indexOf(group);
+		if (previousGroupIndex !== -1) previousPattern.groups.splice(previousGroupIndex, 1);
+		if (!previousPattern.groups.some((candidate) => candidate.resultKey === group.resultKey)) previousPattern.resultKeys.delete(group.resultKey);
+		pattern.groups.push(group);
+		pattern.resultKeys.add(group.resultKey);
+		group.pattern = pattern;
+		return pattern;
+	};
+	const updateGroupRoutePathname = (group, routePathname) => {
+		const normalized = normalizeCacheabilityRoutePathname(routePathname);
+		if (normalized === group.routePathname) return;
+		const pattern = group.pattern;
+		const previousResultKey = group.resultKey;
+		group.routePathname = normalized;
+		group.resultKey = normalized;
+		if (!pattern.groups.some((candidate) => candidate.resultKey === previousResultKey)) pattern.resultKeys.delete(previousResultKey);
+		pattern.resultKeys.add(group.resultKey);
+	};
+	const deferPairedRepresentationsAtOriginalRoute = (group) => {
+		const pairedTargets = group.targets.filter((target) => target !== group.primary);
+		if (pairedTargets.length === 0) return;
+		group.targets = [group.primary];
+		for (const target of pairedTargets) {
+			const routePathname = target.route?.cacheabilityProbe?.concretePathname ?? cacheabilityRoutePathname(target.pathname, target.kind);
+			const deferredGroup = {
+				deferred: true,
+				pattern: group.pattern,
+				primary: target,
+				resultKey: routePathname,
+				routePathname,
+				targets: [target]
+			};
+			group.pattern.groups.push(deferredGroup);
+			group.pattern.resultKeys.add(routePathname);
+		}
+	};
+	const classifyConcretePath = async (group, attemptOptions) => {
+		if (group.pattern.pruned) {
+			skippedPathCount += 1;
+			completedPathCount += 1;
+			reportProgress();
+			return "done";
+		}
+		const target = group.primary;
+		const request = new Request(new URL(target.pathname, options.targetUrl), { headers: target.headers });
+		const identity = cacheabilityRequestIdentity(request);
+		if (!identity || identity.representation !== target.kind) {
+			failures.push(`${target.label}: warm request does not have a cacheable request identity`);
+			completedPathCount += 1;
+			reportProgress();
+			return "done";
+		}
+		const result = await probeTarget({
+			expectedBuildId: options.expectedResponseBuildId,
+			fetchImpl: options.fetchImpl ?? fetch,
+			getDeadlineAt,
+			headers: options.headers,
+			retries: attemptOptions.inlineRetries,
+			retryDelayMs,
+			phaseTimeoutMs,
+			secret,
+			target,
+			targetUrl: options.targetUrl,
+			timeoutMs
+		});
+		if (limitFailure) return "done";
+		if (result.phaseTimedOut) {
+			phaseTimedOut = true;
+			return "done";
+		}
+		if (result.state === "probe-failed" && result.retryable === true && attemptOptions.deferRetry) return "retry";
+		lastProgressAt = Date.now();
+		probed += 1;
+		if (result.version !== 1 || result.kind !== "app-page" && result.kind !== "app-route" && result.kind !== "pages-page" || typeof result.pattern !== "string" || !result.pattern.startsWith("/") || !isProbeRouteState(result.state) || result.scope !== void 0 && result.scope !== "identity" && result.scope !== "pattern" || result.scope === "pattern" && result.state !== "dynamic" || result.routePathname !== void 0 && (typeof result.routePathname !== "string" || !result.routePathname.startsWith("/") || result.routePathname.includes("?") || result.routePathname.includes("#")) || result.terminal !== void 0 && result.terminal !== true || result.terminal === true && (result.state !== "dynamic" || result.scope !== "identity" || !group.pattern.requestStageMayTerminate) || result.rendererStatic !== void 0 && typeof result.rendererStatic !== "boolean" || result.retryable !== void 0 && result.retryable !== true || result.retryable === true && result.state !== "probe-failed" || !Number.isInteger(result.status) || result.status < 100 || result.status > 599) {
+			failures.push(`${target.label}: ${result.reason ?? "probe returned an invalid envelope"}`);
+			completedPathCount += 1;
+			reportProgress();
+			return "done";
+		}
+		if (result.state === "probe-failed") {
+			failures.push(`${target.label}: ${result.reason ?? "probe failed"}`);
+			completedPathCount += 1;
+			reportProgress();
+			return "done";
+		}
+		if (!target.route) {
+			failures.push(`${target.label}: probe resolved without route metadata`);
+			completedPathCount += 1;
+			reportProgress();
+			return "done";
+		}
+		const resolvedRouteChanged = result.kind !== target.route.kind || result.pattern !== target.route.pattern;
+		const resolvedPathnameChanged = result.routePathname !== void 0 && normalizeCacheabilityRoutePathname(result.routePathname) !== group.routePathname;
+		if (resolvedRouteChanged) {
+			if (target.route.cacheabilityProbe?.routeMayResolve !== true) {
+				failures.push(`${target.label}: probe resolved to unexpected route ${result.pattern ?? ""}`);
+				completedPathCount += 1;
+				reportProgress();
+				return "done";
+			}
+			if (result.routePathname === void 0) {
+				failures.push(`${target.label}: probe resolved without a concrete route pathname`);
+				completedPathCount += 1;
+				reportProgress();
+				return "done";
+			}
+		}
+		if (target.route.cacheabilityProbe?.routeMayResolve === true && (resolvedRouteChanged || resolvedPathnameChanged)) deferPairedRepresentationsAtOriginalRoute(group);
+		if (resolvedRouteChanged) moveGroupToResolvedRoute(group, {
+			kind: result.kind,
+			pattern: result.pattern
+		});
+		if (result.routePathname !== void 0) updateGroupRoutePathname(group, result.routePathname);
+		const classification = {
+			rendererStatic: result.rendererStatic === true,
+			representation: target.kind,
+			state: result.state,
+			terminal: result.terminal === true
+		};
+		group.result = classification;
+		const previousClassification = group.pattern.results.get(group.resultKey);
+		if (!previousClassification || previousClassification.state === "static-candidate" && classification.state === "dynamic" || previousClassification.state === classification.state && previousClassification.rendererStatic && !classification.rendererStatic) group.pattern.results.set(group.resultKey, classification);
+		if (result.state === "dynamic" && result.scope === "pattern" && group.pattern.canPrune) {
+			group.pattern.pruned = true;
+			dynamicPathCount += 1;
+			completedPathCount += 1;
+			reportProgress();
+			return "done";
+		}
+		if (result.state === "static-candidate") staticPathCount += 1;
+		else dynamicPathCount += 1;
+		completedPathCount += 1;
+		reportProgress();
+		return "done";
+	};
+	reportProgress();
+	const routeMovingGroups = groups.filter((group) => group.primary.route?.cacheabilityProbe?.routeMayResolve === true);
+	const routeMovingGroupSet = new Set(routeMovingGroups);
+	const readyGroups = [...routeMovingGroups];
+	const readyGroupSet = new Set(routeMovingGroups);
+	for (const pattern of patterns.values()) {
+		const representative = pattern.groups[0];
+		if (!representative || readyGroupSet.has(representative)) continue;
+		readyGroups.push(representative);
+		readyGroupSet.add(representative);
+	}
+	for (const group of groups) {
+		if (readyGroupSet.has(group)) continue;
+		readyGroups.push(group);
+		readyGroupSet.add(group);
+	}
+	const deferredUntilRouteMoversSettle = [];
+	const retriesUsedByGroup = /* @__PURE__ */ new Map();
+	const retryGroupSet = /* @__PURE__ */ new Set();
+	const active = /* @__PURE__ */ new Set();
+	let nextReadyIndex = 0;
+	let pendingRouteMovers = routeMovingGroups.length;
+	const enqueue = (scheduledGroups) => {
+		readyGroups.push(...scheduledGroups);
+	};
+	const startGroup = (group) => {
+		const task = (async () => {
+			const isRouteMover = routeMovingGroupSet.has(group);
+			if (!isRouteMover && group.pattern.pruned && pendingRouteMovers > 0) {
+				deferredUntilRouteMoversSettle.push(group);
+				return;
+			}
+			const retriesUsed = retriesUsedByGroup.get(group) ?? 0;
+			if (await classifyConcretePath(group, {
+				deferRetry: retriesUsed < retries,
+				inlineRetries: 0
+			}) === "retry") {
+				retriesUsedByGroup.set(group, retriesUsed + 1);
+				retryGroupSet.add(group);
+				return;
+			}
+			if (isRouteMover && --pendingRouteMovers === 0) enqueue(deferredUntilRouteMoversSettle.splice(0));
+		})();
+		active.add(task);
+		task.then(() => active.delete(task), () => active.delete(task));
+	};
+	const runReadyGroups = async () => {
+		while (!limitFailure && !phaseTimedOut && (nextReadyIndex < readyGroups.length || active.size > 0)) {
+			while (active.size < concurrency && nextReadyIndex < readyGroups.length) startGroup(readyGroups[nextReadyIndex++]);
+			if (active.size > 0) await Promise.race(active);
+		}
+		await Promise.all(active);
+	};
+	await runReadyGroups();
+	let retryGroups = groups.filter((group) => retryGroupSet.has(group));
+	while (retryGroups.length > 0) {
+		if (retryDelayMs > 0) {
+			const delayMs = Math.min(retryDelayMs, Math.max(0, getDeadlineAt() - Date.now()));
+			if (delayMs <= 0) {
+				phaseTimedOut = true;
+				break;
+			}
+			await setTimeout$1(delayMs);
+		}
+		retryGroupSet.clear();
+		readyGroups.splice(0, readyGroups.length, ...retryGroups);
+		nextReadyIndex = 0;
+		await runReadyGroups();
+		retryGroups = groups.filter((group) => retryGroupSet.has(group));
+	}
+	if (limitFailure) throw limitFailure;
+	if (phaseTimedOut || Date.now() >= getDeadlineAt()) throw new Error(`cacheability probing made no progress for ${phaseTimeoutMs}ms`);
+	let classified = 0;
+	let dynamic = 0;
+	let skipped = 0;
+	const fallbackRoutes = /* @__PURE__ */ new Map();
+	for (const fallbackRoute of options.fallbackRoutePatterns ?? []) {
+		const key = cacheabilityManifestRouteKey(fallbackRoute.kind, fallbackRoute.pattern);
+		fallbackRoutes.set(key, fallbackRoute);
+	}
+	for (const [key, fallbackRoute] of fallbackRoutes) {
+		if (patterns.has(key)) continue;
+		if (!addRouteWithinManifestLimits(key, {
+			kind: fallbackRoute.kind,
+			pattern: fallbackRoute.pattern,
+			state: "static-candidate"
+		})) break;
+		classified += 1;
+	}
+	if (limitFailure) throw limitFailure;
+	for (const pattern of patterns.values()) {
+		if (pattern.pruned) {
+			classified += 1;
+			dynamic += 1;
+			skipped += 1;
+			const loadingShellTargets = pattern.groups.flatMap((group) => group.targets.filter((target) => target.kind === "rsc-loading-shell"));
+			if (loadingShellTargets.length > 0) {
+				cacheableTargets.push(...loadingShellTargets);
+				speculativeTargets.push(...loadingShellTargets);
+				const route = {
+					kind: pattern.route.kind,
+					pattern: pattern.route.pattern,
+					runtimeRepresentation: "rsc-loading-shell",
+					state: "runtime-check"
+				};
+				if (!addRouteWithinManifestLimits(pattern.key, route)) break;
+			}
+			continue;
+		}
+		if (pattern.results.size === 0 && !pattern.groups.some((group) => group.deferred)) continue;
+		classified += 1;
+		if (Array.from(pattern.results.values()).some((result) => result.state === "dynamic")) dynamic += 1;
+		const rendererStaticTargets = /* @__PURE__ */ new Map();
+		const runtimePathSet = /* @__PURE__ */ new Set();
+		for (const group of pattern.groups) {
+			if (group.deferred) {
+				runtimePathSet.add(group.routePathname);
+				cacheableTargets.push(...group.targets);
+				speculativeTargets.push(...group.targets);
+				continue;
+			}
+			const result = group.result;
+			if (result?.state === "static-candidate") {
+				if (result.rendererStatic) {
+					const previous = rendererStaticTargets.get(group.routePathname);
+					if (!previous || targetPreference(group.primary) < targetPreference(previous)) rendererStaticTargets.set(group.routePathname, group.primary);
+				} else runtimePathSet.add(group.routePathname);
+				cacheableTargets.push(...group.targets);
+				speculativeTargets.push(...group.targets.filter((target) => target !== group.primary));
+				continue;
+			}
+			const pairedTargets = group.targets.filter((target) => target !== group.primary);
+			if (result?.terminal !== true || pairedTargets.length > 0) runtimePathSet.add(group.routePathname);
+			if (!pattern.pruned) {
+				cacheableTargets.push(...pairedTargets);
+				speculativeTargets.push(...pairedTargets);
+			}
+		}
+		const staticPaths = {};
+		for (const [routePathname, staticTarget] of rendererStaticTargets) {
+			if (runtimePathSet.has(routePathname)) continue;
+			const paths = staticPaths[staticTarget.kind] ?? [];
+			paths.push(routePathname);
+			staticPaths[staticTarget.kind] = paths;
+		}
+		for (const paths of Object.values(staticPaths)) paths?.sort();
+		const allObservedPathsStaticallyGenerated = pattern.results.size === pattern.resultKeys.size && Array.from(pattern.results.values()).every((result) => result.state === "static-candidate") && Array.from(pattern.results.values()).every((result) => result.rendererStatic);
+		const hasStaticFallback = fallbackRoutes.has(pattern.key);
+		const soleGroup = pattern.groups.length === 1 ? pattern.groups[0] : null;
+		const literalPatternNamesSolePath = soleGroup !== null && !/(^|\/):/.test(pattern.route.pattern) && normalizeCacheabilityRoutePathname(pattern.route.pattern) === soleGroup.routePathname;
+		let route;
+		if (literalPatternNamesSolePath) {
+			const result = pattern.results.get(soleGroup.resultKey);
+			route = result?.state === "static-candidate" ? pattern.route.kind === "app-route" ? {
+				kind: pattern.route.kind,
+				pattern: pattern.route.pattern,
+				state: "static-candidate"
+			} : result.rendererStatic ? {
+				kind: pattern.route.kind,
+				pattern: pattern.route.pattern,
+				state: "runtime-check",
+				staticRepresentation: result.representation
+			} : {
+				kind: pattern.route.kind,
+				pattern: pattern.route.pattern,
+				state: "runtime-check"
+			} : {
+				kind: pattern.route.kind,
+				pattern: pattern.route.pattern,
+				state: "runtime-check"
+			};
+		} else route = compactManifestRoutePaths({
+			kind: pattern.route.kind,
+			pattern: pattern.route.pattern,
+			state: "runtime-check",
+			...hasStaticFallback || allObservedPathsStaticallyGenerated ? {
+				allowUnknown: true,
+				unknownState: "static-candidate"
+			} : {},
+			...runtimePathSet.size > 0 ? { runtimePaths: Array.from(runtimePathSet).sort() } : {},
+			...Object.keys(staticPaths).length > 0 ? { staticPaths } : {}
+		});
+		if (!addRouteWithinManifestLimits(pattern.key, route)) break;
+	}
+	if (limitFailure) throw limitFailure;
+	const sortedRoutes = Object.fromEntries(Object.entries(routes).sort(([first], [second]) => first.localeCompare(second)));
+	cacheableTargets.sort((first, second) => `${first.kind}\0${first.sourcePathname}`.localeCompare(`${second.kind}\0${second.sourcePathname}`));
+	speculativeTargets.sort((first, second) => `${first.kind}\0${first.sourcePathname}`.localeCompare(`${second.kind}\0${second.sourcePathname}`));
+	return {
+		cacheableTargets,
+		classified,
+		dynamic,
+		failures,
+		manifest: {
+			buildId: options.buildId,
+			routes: sortedRoutes,
+			version: 1
+		},
+		probed,
+		skipped,
+		speculativeTargets
+	};
+}
+//#endregion
+export { DEFAULT_CACHEABILITY_PROBE_PHASE_TIMEOUT_MS, DEFAULT_CACHEABILITY_PROBE_RETRIES, DEFAULT_CACHEABILITY_PROBE_RETRY_DELAY_MS, probeStagedWorkerCacheability, readPrerenderSecret };