@vinext/cloudflare 1.0.0-beta.7 → 1.0.0-beta.9

package/dist/cacheability-artifact.js

@@ -135,7 +135,33 @@ function assertManifestModuleReachable(configPath) {
 	if (typeof main !== "string" || main.length === 0) throw new Error("Two-stage CDN warming requires a generated Wrangler main module.");
 	const mainPath = path.resolve(serverDirectory, main);
 	if (!fs.existsSync(mainPath) || !fs.lstatSync(mainPath).isFile()) throw new Error("Two-stage CDN warming could not find the generated Wrangler main module.");
-	if (!hasStaticModuleSpecifier(fs.readFileSync(mainPath, "utf8"), `./${CACHEABILITY_MANIFEST_MODULE}`)) throw new Error(`Two-stage CDN warming requires the generated Worker main module to import ${CACHEABILITY_MANIFEST_MODULE}.`);
+	const viteManifestPath = path.join(serverDirectory, ".vite", "manifest.json");
+	let viteManifest;
+	try {
+		viteManifest = JSON.parse(fs.readFileSync(viteManifestPath, "utf8"));
+	} catch (cause) {
+		throw new Error("Two-stage CDN warming could not read the generated Vite manifest.", { cause });
+	}
+	const normalizedMain = main.replace(/^\.\//, "");
+	const entryKey = Object.entries(viteManifest).find(([, entry]) => entry?.file === normalizedMain)?.[0];
+	const queue = entryKey ? [entryKey] : [];
+	const visited = /* @__PURE__ */ new Set();
+	let reachable = false;
+	while (queue.length > 0 && !reachable) {
+		const key = queue.shift();
+		if (visited.has(key)) continue;
+		visited.add(key);
+		const entry = viteManifest[key];
+		if (!entry || typeof entry.file !== "string") continue;
+		const modulePath = path.resolve(serverDirectory, entry.file);
+		if (fs.existsSync(modulePath) && fs.lstatSync(modulePath).isFile()) {
+			const relativeManifest = path.relative(path.dirname(modulePath), path.join(serverDirectory, CACHEABILITY_MANIFEST_MODULE)).split(path.sep).join("/");
+			const specifier = relativeManifest.startsWith(".") ? relativeManifest : `./${relativeManifest}`;
+			reachable = hasStaticModuleSpecifier(fs.readFileSync(modulePath, "utf8"), specifier);
+		}
+		for (const references of [entry.imports, entry.dynamicImports]) if (Array.isArray(references)) queue.push(...references.filter((value) => typeof value === "string"));
+	}
+	if (!reachable) throw new Error(`Two-stage CDN warming requires the generated Worker graph to statically import ${CACHEABILITY_MANIFEST_MODULE}.`);
 }
 /**
 * Write the version-specific manifest into the built Worker artifact.

package/dist/cacheability-manifest-limits.d.ts

@@ -1,5 +1,4 @@
 //#region src/cacheability-manifest-limits.d.ts
-declare const MAX_CACHEABILITY_MANIFEST_BYTES: number;
-declare function cacheabilityManifestByteLimitError(manifestBytes: number, limit?: number): Error;
-//#endregion
-export { MAX_CACHEABILITY_MANIFEST_BYTES, cacheabilityManifestByteLimitError };
+export declare const MAX_CACHEABILITY_MANIFEST_BYTES: number;
+export declare function cacheabilityManifestByteLimitError(manifestBytes: number, limit?: number): Error;
+//#endregion

package/dist/cacheability-manifest-limits.js

@@ -1,5 +1,5 @@
 //#region src/cacheability-manifest-limits.ts
-const MAX_CACHEABILITY_MANIFEST_BYTES = 2 * 1024 * 1024;
+const MAX_CACHEABILITY_MANIFEST_BYTES = 2097152;
 function cacheabilityManifestByteLimitError(manifestBytes, limit = MAX_CACHEABILITY_MANIFEST_BYTES) {
 	return /* @__PURE__ */ new Error(`Two-stage CDN warming produced a ${manifestBytes}-byte route-pattern cacheability manifest; the limit is ${limit} bytes. Reduce the number or length of route patterns, or split the deployment before retrying.`);
 }

package/dist/cacheability-probe.d.ts

@@ -2,10 +2,10 @@ import { CdnWarmTarget } from "./cdn-warm.js";
 import { CacheabilityManifest } from "vinext/internal/server/cacheability-manifest";
 import { PrerenderRoutePattern } from "vinext/internal/build/prerender-paths";
 //#region src/cacheability-probe.d.ts
-declare const DEFAULT_CACHEABILITY_PROBE_PHASE_TIMEOUT_MS = 120000;
-declare const DEFAULT_CACHEABILITY_PROBE_RETRIES = 2;
-declare const DEFAULT_CACHEABILITY_PROBE_RETRY_DELAY_MS = 1000;
-type CacheabilityProbeProgress = {
+export declare const DEFAULT_CACHEABILITY_PROBE_PHASE_TIMEOUT_MS = 120000;
+export declare const DEFAULT_CACHEABILITY_PROBE_RETRIES = 2;
+export declare const DEFAULT_CACHEABILITY_PROBE_RETRY_DELAY_MS = 1000;
+export type CacheabilityProbeProgress = {
   completed: number;
   dynamic: number;
   failed: number;
@@ -14,7 +14,7 @@ type CacheabilityProbeProgress = {
   static: number;
   total: number;
 };
-type CacheabilityProbeResult = {
+export type CacheabilityProbeResult = {
   cacheableTargets: CdnWarmTarget[];
   classified: number;
   dynamic: number;
@@ -25,8 +25,8 @@ type CacheabilityProbeResult = {
   /** Paired representations admitted only if their own final warm render remains cacheable. */
   speculativeTargets: CdnWarmTarget[];
 };
-declare function readPrerenderSecret(root: string): string;
-declare function probeStagedWorkerCacheability(options: {
+export declare function readPrerenderSecret(root: string): string;
+export declare function probeStagedWorkerCacheability(options: {
   buildId: string;
   concurrency?: number;
   expectedResponseBuildId?: string;
@@ -46,5 +46,4 @@ declare function probeStagedWorkerCacheability(options: {
     maxBytes?: number;
   };
 }): Promise<CacheabilityProbeResult>;
-//#endregion
-export { CacheabilityProbeProgress, CacheabilityProbeResult, DEFAULT_CACHEABILITY_PROBE_PHASE_TIMEOUT_MS, DEFAULT_CACHEABILITY_PROBE_RETRIES, DEFAULT_CACHEABILITY_PROBE_RETRY_DELAY_MS, probeStagedWorkerCacheability, readPrerenderSecret };
+//#endregion

package/dist/cacheability-probe.js

@@ -6,13 +6,13 @@ 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_PRERENDER_SECRET_HEADER } from "vinext/internal/server/headers";
+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 = 64 * 1024;
+const MAX_CACHEABILITY_PROBE_ENVELOPE_BYTES = 65536;
 function sharedPathPrefix(pathnames) {
 	if (pathnames.length === 0) return null;
 	let prefix = pathnames[0];
@@ -43,6 +43,9 @@ function compactManifestRoutePaths(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"));
@@ -51,11 +54,7 @@ function readPrerenderSecret(root) {
 	return secret;
 }
 async function readProbeEnvelope(response) {
-	if (!response.body) return {
-		reason: "probe returned invalid JSON",
-		state: "probe-failed",
-		version: 1
-	};
+	if (!response.body) throw new Error("probe returned invalid JSON");
 	const reader = response.body.getReader();
 	const chunks = [];
 	let bytes = 0;
@@ -74,30 +73,20 @@ async function readProbeEnvelope(response) {
 			}
 			chunks.push(result.value);
 		}
-	} catch (error) {
-		return {
-			reason: error instanceof Error ? error.message : String(error),
-			state: "probe-failed",
-			version: 1
-		};
 	} finally {
 		reader.releaseLock();
 	}
 	try {
 		return JSON.parse(Buffer.concat(chunks, bytes).toString("utf8"));
 	} catch {
-		return {
-			reason: "probe returned invalid JSON",
-			state: "probe-failed",
-			version: 1
-		};
+		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("Cache-Control", "no-cache");
 	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();
@@ -107,13 +96,16 @@ async function probeTarget(options) {
 		state: "probe-failed",
 		version: 1
 	});
-	for (let attempt = 0; attempt <= options.retries; attempt++) {
+	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 retryable = true;
+		let retryUntilDeadline = false;
 		try {
 			const url = new URL(options.target.pathname, options.targetUrl);
 			url.searchParams.set(VINEXT_CACHEABILITY_PROBE_QUERY_PARAM, `${probeId}-${attempt}`);
@@ -128,7 +120,8 @@ async function probeTarget(options) {
 					return {
 						kind: "retry",
 						reason: "probe reached an unexpected Worker build",
-						retryable: true
+						retryable: true,
+						retryUntilDeadline: true
 					};
 				}
 				if (!response.ok) {
@@ -136,12 +129,20 @@ async function probeTarget(options) {
 					return {
 						kind: "retry",
 						reason: `probe returned HTTP ${response.status}`,
-						retryable: response.status === 404 || response.status === 503
+						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: await readProbeEnvelope(response)
+					payload
 				};
 			})();
 			const timedOut = new Promise((_resolve, reject) => {
@@ -163,13 +164,15 @@ async function probeTarget(options) {
 			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 || attempt === options.retries) break;
+		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();
@@ -178,6 +181,7 @@ async function probeTarget(options) {
 	}
 	return {
 		reason,
+		...retryable ? { retryable: true } : {},
 		state: "probe-failed",
 		version: 1
 	};
@@ -215,7 +219,7 @@ async function probeStagedWorkerCacheability(options) {
 		return target.kind === "html" ? 0 : target.kind === "rsc-full" ? 1 : 2;
 	};
 	const patterns = /* @__PURE__ */ new Map();
-	const targetsByConcretePath = /* @__PURE__ */ new Map();
+	const routableTargets = [];
 	let missingRouteMetadata = 0;
 	for (const target of options.targets) {
 		if (!target.route) {
@@ -227,36 +231,46 @@ async function probeStagedWorkerCacheability(options) {
 			canPrune: true,
 			groups: [],
 			key,
-			pathnames: /* @__PURE__ */ new Set(),
+			resultKeys: /* @__PURE__ */ new Set(),
 			pruned: false,
 			results: /* @__PURE__ */ new Map(),
-			route: target.route
+			route: target.route,
+			requestStageMayTerminate: false
 		};
-		pattern.canPrune &&= target.route.cacheabilityProbe?.canPrunePattern === true;
+		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);
-		const routePathname = target.route.cacheabilityProbe?.concretePathname ?? cacheabilityRoutePathname(target.pathname, target.kind);
-		pattern.pathnames.add(routePathname);
-		const concreteKey = `${key}\0${routePathname}`;
-		const groupTargets = targetsByConcretePath.get(concreteKey) ?? [];
-		groupTargets.push(target);
-		targetsByConcretePath.set(concreteKey, groupTargets);
+		routableTargets.push(target);
 	}
 	if (missingRouteMetadata > 0) failures.push(`${missingRouteMetadata} warm target${missingRouteMetadata === 1 ? " is" : "s are"} missing route-pattern metadata`);
-	const groups = Array.from(targetsByConcretePath, ([concreteKey, groupTargets]) => {
-		const route = groupTargets[0].route;
+	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 = concreteKey.slice(key.length + 1);
-		groupTargets.sort((first, second) => {
+		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 = {
-			pattern,
-			primary: groupTargets[0],
-			routePathname,
-			targets: groupTargets
+			...targetGroup,
+			deferred: false,
+			primary: targetGroup.targets[0]
 		};
-		pattern.groups.push(group);
+		targetGroup.pattern.groups.push(group);
 		return group;
 	});
 	const reportProgress = () => {
@@ -283,27 +297,85 @@ async function probeStagedWorkerCacheability(options) {
 		manifestBytes = nextManifestBytes;
 		return true;
 	};
-	const classifyConcretePath = async (group) => {
+	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;
+			return "done";
 		}
 		const target = group.primary;
-		const identity = cacheabilityRequestIdentity(new Request(new URL(target.pathname, options.targetUrl), { headers: target.headers }));
+		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;
+			return "done";
 		}
 		const result = await probeTarget({
 			expectedBuildId: options.expectedResponseBuildId,
 			fetchImpl: options.fetchImpl ?? fetch,
 			getDeadlineAt,
 			headers: options.headers,
-			retries,
+			retries: attemptOptions.inlineRetries,
 			retryDelayMs,
 			phaseTimeoutMs,
 			secret,
@@ -311,66 +383,146 @@ async function probeStagedWorkerCacheability(options) {
 			targetUrl: options.targetUrl,
 			timeoutMs
 		});
-		probed += 1;
-		lastProgressAt = Date.now();
-		if (limitFailure) return;
+		if (limitFailure) return "done";
 		if (result.phaseTimedOut) {
 			phaseTimedOut = true;
-			return;
+			return "done";
 		}
-		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.rendererStatic !== void 0 && typeof result.rendererStatic !== "boolean" || !Number.isInteger(result.status) || result.status < 100 || result.status > 599) {
+		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;
+			return "done";
 		}
 		if (result.state === "probe-failed") {
 			failures.push(`${target.label}: ${result.reason ?? "probe failed"}`);
 			completedPathCount += 1;
 			reportProgress();
-			return;
+			return "done";
 		}
-		if (!target.route || result.kind !== target.route.kind || result.pattern !== target.route.pattern) {
-			failures.push(`${target.label}: probe resolved to unexpected route ${result.pattern ?? ""}`);
+		if (!target.route) {
+			failures.push(`${target.label}: probe resolved without route metadata`);
 			completedPathCount += 1;
 			reportProgress();
-			return;
+			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;
+			return "done";
 		}
-		group.pattern.results.set(group.routePathname, {
-			rendererStatic: result.rendererStatic === true,
-			representation: target.kind,
-			state: result.state
-		});
 		if (result.state === "static-candidate") staticPathCount += 1;
 		else dynamicPathCount += 1;
 		completedPathCount += 1;
 		reportProgress();
-	};
-	const runGroups = async (scheduledGroups) => {
-		let nextIndex = 0;
-		const worker = async () => {
-			while (!limitFailure && !phaseTimedOut && nextIndex < scheduledGroups.length) await classifyConcretePath(scheduledGroups[nextIndex++]);
-		};
-		await Promise.all(Array.from({ length: Math.min(concurrency, scheduledGroups.length) }, () => worker()));
+		return "done";
 	};
 	reportProgress();
-	const representativeGroups = [];
-	const siblingGroups = [];
-	const scheduledPatterns = /* @__PURE__ */ new Set();
-	for (const group of groups) if (scheduledPatterns.has(group.pattern.key)) siblingGroups.push(group);
-	else {
-		scheduledPatterns.add(group.pattern.key);
-		representativeGroups.push(group);
+	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));
 	}
-	await runGroups(representativeGroups);
-	if (!limitFailure && !phaseTimedOut) await runGroups(siblingGroups);
 	if (limitFailure) throw limitFailure;
 	if (phaseTimedOut || Date.now() >= getDeadlineAt()) throw new Error(`cacheability probing made no progress for ${phaseTimeoutMs}ms`);
 	let classified = 0;
@@ -410,38 +562,50 @@ async function probeStagedWorkerCacheability(options) {
 			}
 			continue;
 		}
-		if (pattern.results.size === 0) 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 staticPaths = {};
+		const rendererStaticTargets = /* @__PURE__ */ new Map();
 		const runtimePathSet = /* @__PURE__ */ new Set();
 		for (const group of pattern.groups) {
-			const result = pattern.results.get(group.routePathname);
+			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 paths = staticPaths[result.representation] ?? [];
-					paths.push(group.routePathname);
-					staticPaths[result.representation] = paths;
+					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;
 			}
-			runtimePathSet.add(group.routePathname);
+			const pairedTargets = group.targets.filter((target) => target !== group.primary);
+			if (result?.terminal !== true || pairedTargets.length > 0) runtimePathSet.add(group.routePathname);
 			if (!pattern.pruned) {
-				const pairedTargets = group.targets.filter((target) => target !== group.primary);
 				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.pathnames.size && runtimePathSet.size === 0 && Array.from(pattern.results.values()).every((result) => result.rendererStatic);
+		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.routePathname);
+			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,