@vinext/cloudflare 1.0.0-beta.9 → 1.0.1

package/dist/cache/static-assets-adapter.runtime.js

@@ -0,0 +1,94 @@
+import { STATIC_ASSET_CACHE_PATH } from "./static-assets-adapter.shared.js";
+import { DefaultCdnCacheAdapter } from "vinext/shims/cdn-cache";
+//#region src/cache/static-assets-adapter.runtime.ts
+async function cacheAssetId(key) {
+	const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(key));
+	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function isMetadata(value) {
+	return value !== null && typeof value === "object" && "kind" in value && (value.kind === "html" || value.kind === "rsc" || value.kind === "route" || value.kind === "pages" || value.kind === "redirect" || value.kind === "not-found") && "lastModified" in value && typeof value.lastModified === "number";
+}
+var StaticAssetsCacheAdapter = class {
+	assets;
+	hasPrerenderedPages = true;
+	ownsBackgroundRevalidation = false;
+	indexPromise;
+	constructor(assets) {
+		this.assets = assets;
+	}
+	loadIndex() {
+		return this.indexPromise ??= this.assets.fetch(`https://vinext.invalid${STATIC_ASSET_CACHE_PATH}/index.json`).then(async (response) => response.ok ? await response.json() : null).then((value) => value !== null && typeof value === "object" ? value : null);
+	}
+	async get(key) {
+		const id = await cacheAssetId(key);
+		const metadata = (await this.loadIndex())?.[id];
+		if (!isMetadata(metadata)) return null;
+		const extension = metadata.kind;
+		const bodyResponse = await this.assets.fetch(`https://vinext.invalid${STATIC_ASSET_CACHE_PATH}/${id}.${extension}`);
+		if (!bodyResponse.ok) return null;
+		let value;
+		if (metadata.kind === "not-found") {
+			await bodyResponse.body?.cancel();
+			value = null;
+		} else if (metadata.kind === "redirect") value = {
+			kind: "REDIRECT",
+			props: await bodyResponse.json()
+		};
+		else if (metadata.kind === "pages") {
+			const { html, pageData } = await bodyResponse.json();
+			value = {
+				kind: "PAGES",
+				html,
+				pageData,
+				headers: metadata.headers,
+				status: metadata.status
+			};
+		} else if (metadata.kind === "html") value = {
+			kind: "APP_PAGE",
+			html: await bodyResponse.text(),
+			rscData: void 0,
+			headers: metadata.headers,
+			postponed: void 0,
+			prerendered: true,
+			status: metadata.status
+		};
+		else if (metadata.kind === "rsc") value = {
+			kind: "APP_PAGE",
+			html: "",
+			rscData: await bodyResponse.arrayBuffer(),
+			headers: void 0,
+			postponed: void 0,
+			prerendered: true,
+			status: void 0
+		};
+		else value = {
+			kind: "APP_ROUTE",
+			body: await bodyResponse.arrayBuffer(),
+			headers: metadata.headers ?? {},
+			status: metadata.status ?? 200
+		};
+		return {
+			lastModified: metadata.lastModified,
+			...metadata.cacheControl ? { cacheControl: metadata.cacheControl } : {},
+			value
+		};
+	}
+	async set(_key, _data, _ctx) {}
+	buildResponseHeaders(input) {
+		return { "Cache-Control": input.pendingDynamicCheck ? "no-store, must-revalidate" : input.cacheControl };
+	}
+	buildResponseIdentityHeaders() {
+		const buildId = process.env.__VINEXT_RSC_BUILD_IDENTITY || process.env.__VINEXT_BUILD_ID;
+		return buildId ? { "X-Vinext-Build-Id": buildId } : {};
+	}
+	async revalidateTag(_tags, _durations) {}
+};
+function createStaticAssetsCacheAdapter({ env, options } = {}) {
+	if (process.env.VINEXT_PRERENDER === "1") return new DefaultCdnCacheAdapter(process.env.__VINEXT_RSC_BUILD_IDENTITY || process.env.__VINEXT_BUILD_ID);
+	const binding = options?.binding ?? "ASSETS";
+	const assets = env?.[binding];
+	if (!assets || typeof assets !== "object" || !("fetch" in assets) || typeof assets.fetch !== "function") throw new Error(`[vinext] Static Assets binding \`${binding}\` is not configured.`);
+	return new StaticAssetsCacheAdapter(assets);
+}
+//#endregion
+export { StaticAssetsCacheAdapter, createStaticAssetsCacheAdapter as default };

package/dist/cache/static-assets-adapter.shared.d.ts

@@ -0,0 +1,12 @@
+import { CacheControlMetadata } from "vinext/shims/cache-handler";
+//#region src/cache/static-assets-adapter.shared.d.ts
+export declare const STATIC_ASSET_CACHE_PATH = "/_vinext/static-cache";
+export type StaticAssetCacheMetadata = {
+  kind: "html" | "rsc" | "route" | "pages" | "redirect" | "not-found";
+  lastModified: number;
+  cacheControl?: CacheControlMetadata;
+  headers?: Record<string, string | string[]>;
+  status?: number;
+};
+export type StaticAssetCacheIndex = Record<string, StaticAssetCacheMetadata>;
+//#endregion

package/dist/cache/static-assets-adapter.shared.js

@@ -0,0 +1,4 @@
+//#region src/cache/static-assets-adapter.shared.ts
+const STATIC_ASSET_CACHE_PATH = "/_vinext/static-cache";
+//#endregion
+export { STATIC_ASSET_CACHE_PATH };

package/dist/cache/workers-cache-cdn-adapter.d.ts

@@ -0,0 +1,58 @@
+//#region src/cache/workers-cache-cdn-adapter.d.ts
+export declare const DEFAULT_CDN_VERSION_METADATA_BINDING = "CF_VERSION_METADATA";
+/** Options accepted by {@link workersCacheCdnAdapter}, forwarded to the runtime factory. */
+export type CdnAdapterOptions = {
+  /** Version metadata binding used to verify version-overridden requests. */
+  versionMetadataBinding?: string;
+};
+/**
+ * Cloudflare CDN cache adapter - edge-managed page-level ISR backed by the
+ * Cloudflare Workers Cache.
+ *
+ * Unlike the data adapter (which stores cache entries in a durable store and
+ * serves HIT/STALE itself), this adapter delegates serving to Workers Cache on
+ * a named Worker entrypoint. The default entrypoint always runs middleware and
+ * request-time routing, then renders bypass requests inline or dispatches shared
+ * requests to the cached response-stage entrypoint.
+ *
+ * The deployment configuration enables Workers Cache only for that response-stage
+ * export, so cache hits do not start the application stage. Legacy Cloudflare
+ * builds receive this policy in their generated Wrangler config. Cloudflare Vite
+ * plugin v2 builds declare the same entrypoint policy in `cloudflare.config.ts`.
+ * Deployment readiness probes still use the uncached response entrypoint to
+ * verify that named response entrypoints are available.
+ *
+ * The adapter adds a transport-only URL digest so distinct response-stage
+ * identities cannot collide. Workers Cache owns this key independently of
+ * zone Cache Rules.
+ */
+export declare function workersCacheCdnAdapter(options?: CdnAdapterOptions): {
+  adapter: string;
+  options: CdnAdapterOptions | undefined;
+  output: {
+    entry: string;
+    matchesBuild({ plugins }: {
+      plugins: readonly {
+        name?: string;
+      }[];
+    }): boolean;
+    transformHostEntry({ code, id }: {
+      code: string;
+      id: string;
+    }): string | null;
+    finalizeBuildOutput({ root, outDir, isPrimaryServerOutput }: {
+      root: string;
+      outDir: string;
+      isPrimaryServerOutput: boolean;
+    }): Promise<void>;
+    type: "multi-stage";
+  };
+  capabilities: {
+    buildIdentity: "response-header";
+    isResponsePolicyHeader: (name: string) => boolean;
+    requestRouting: "uncached-stage";
+    responseVary: "verbatim";
+    routeCacheability: "probe-manifest";
+  };
+};
+//#endregion

package/dist/cache/workers-cache-cdn-adapter.js

@@ -0,0 +1,65 @@
+import { finalizeCdnAdapterBuildOutput } from "./cdn-adapter-config.js";
+import { fileURLToPath } from "node:url";
+//#region src/cache/workers-cache-cdn-adapter.ts
+const DEFAULT_CDN_VERSION_METADATA_BINDING = "CF_VERSION_METADATA";
+const CLOUDFLARE_WORKER_ENTRY_ID = "virtual:cloudflare/worker-entry";
+/**
+* Cloudflare CDN cache adapter - edge-managed page-level ISR backed by the
+* Cloudflare Workers Cache.
+*
+* Unlike the data adapter (which stores cache entries in a durable store and
+* serves HIT/STALE itself), this adapter delegates serving to Workers Cache on
+* a named Worker entrypoint. The default entrypoint always runs middleware and
+* request-time routing, then renders bypass requests inline or dispatches shared
+* requests to the cached response-stage entrypoint.
+*
+* The deployment configuration enables Workers Cache only for that response-stage
+* export, so cache hits do not start the application stage. Legacy Cloudflare
+* builds receive this policy in their generated Wrangler config. Cloudflare Vite
+* plugin v2 builds declare the same entrypoint policy in `cloudflare.config.ts`.
+* Deployment readiness probes still use the uncached response entrypoint to
+* verify that named response entrypoints are available.
+*
+* The adapter adds a transport-only URL digest so distinct response-stage
+* identities cannot collide. Workers Cache owns this key independently of
+* zone Cache Rules.
+*/
+function workersCacheCdnAdapter(options) {
+	if (options?.versionMetadataBinding !== void 0 && (typeof options.versionMetadataBinding !== "string" || options.versionMetadataBinding.length === 0)) throw new TypeError("[vinext] workersCacheCdnAdapter({ versionMetadataBinding }) must be a non-empty string binding name.");
+	const versionMetadataBinding = options?.versionMetadataBinding ?? "CF_VERSION_METADATA";
+	const bindingIsExplicit = options?.versionMetadataBinding !== void 0;
+	const workerEntry = fileURLToPath(import.meta.resolve("./cdn-adapter.worker.js"));
+	return {
+		adapter: fileURLToPath(import.meta.resolve("./cdn-adapter.runtime.js")),
+		options,
+		output: {
+			entry: workerEntry,
+			matchesBuild({ plugins }) {
+				return plugins.some(({ name }) => name === "vite-plugin-cloudflare" || name?.startsWith("vite-plugin-cloudflare:"));
+			},
+			transformHostEntry({ code, id }) {
+				if ((id.charCodeAt(0) === 0 ? id.slice(1) : id) !== CLOUDFLARE_WORKER_ENTRY_ID) return null;
+				return `${code}\nexport { VinextCachedResponse, VinextUncachedResponse } from ${JSON.stringify(workerEntry)};\n`;
+			},
+			finalizeBuildOutput({ root, outDir, isPrimaryServerOutput }) {
+				return finalizeCdnAdapterBuildOutput({
+					root,
+					outDir,
+					isPrimaryServerOutput,
+					binding: versionMetadataBinding,
+					bindingIsExplicit
+				});
+			},
+			type: "multi-stage"
+		},
+		capabilities: {
+			buildIdentity: "response-header",
+			isResponsePolicyHeader: (name) => name.toLowerCase() === "cdn-cache-control" || name.toLowerCase() === "cloudflare-cdn-cache-control",
+			requestRouting: "uncached-stage",
+			responseVary: "verbatim",
+			routeCacheability: "probe-manifest"
+		}
+	};
+}
+//#endregion
+export { DEFAULT_CDN_VERSION_METADATA_BINDING, workersCacheCdnAdapter };

package/dist/cacheability-artifact.d.ts

@@ -1,9 +1,15 @@
 import { CacheabilityManifest } from "vinext/internal/server/cacheability-manifest";
 //#region src/cacheability-artifact.d.ts
+export type CloudflareDeploymentTool = "cf" | "wrangler";
 /**
  * Write the version-specific manifest into the built Worker artifact.
  * The application build already imports this stable module asset, so the
  * completed dist directory remains the exact input to the final upload.
+ *
+ * App Router builds also emit the request stage's projection module. It
+ * carries the App page routes that can admit a query-free entry, so the
+ * request stage can strip the query from those dispatches without loading the
+ * full manifest.
  */
-export declare function writeCacheabilityManifestArtifact(root: string, configuredPath: string | undefined, manifest: CacheabilityManifest): string;
+export declare function writeCacheabilityManifestArtifact(root: string, configuredPath: string | undefined, manifest: CacheabilityManifest, deploymentTool?: CloudflareDeploymentTool): string;
 //#endregion

package/dist/cacheability-artifact.js

@@ -2,7 +2,7 @@ import { cacheabilityManifestByteLimitError } from "./cacheability-manifest-limi
 import fs from "node:fs";
 import path from "node:path";
 import { Buffer } from "node:buffer";
-import { CACHEABILITY_MANIFEST_MODULE } from "vinext/internal/server/cacheability-manifest";
+import { CACHEABILITY_MANIFEST_MODULE, CACHEABILITY_REQUEST_PROJECTION_MODULE, projectCacheabilityManifestForRequestStage } from "vinext/internal/server/cacheability-manifest";
 //#region src/cacheability-artifact.ts
 function tokenizeStaticImports(source) {
 	const tokens = [];
@@ -115,16 +115,12 @@ function hasStaticModuleSpecifier(source, expected) {
 	}
 	return false;
 }
-function resolveGeneratedServerConfig(root, configuredPath) {
+function resolveGeneratedWranglerArtifact(root, configuredPath) {
 	const distDirectory = path.join(root, "dist");
 	const configPath = path.resolve(root, configuredPath ?? "dist/server/wrangler.json");
 	const relativeConfigPath = path.relative(distDirectory, configPath);
 	if (relativeConfigPath.startsWith("..") || path.isAbsolute(relativeConfigPath)) throw new Error("Two-stage CDN warming requires a generated Wrangler config under dist/. Pass --config dist/server/wrangler.json (or another generated dist config).");
 	if (!fs.existsSync(configPath) || !fs.lstatSync(configPath).isFile()) throw new Error(`Two-stage CDN warming requires the generated Wrangler config at ${path.relative(root, configPath)}. Rebuild the app before deploying.`);
-	return configPath;
-}
-function assertManifestModuleReachable(configPath) {
-	const serverDirectory = path.dirname(configPath);
 	let config;
 	try {
 		config = JSON.parse(fs.readFileSync(configPath, "utf8"));
@@ -133,8 +129,36 @@ function assertManifestModuleReachable(configPath) {
 	}
 	const main = config && typeof config === "object" && !Array.isArray(config) ? config.main : void 0;
 	if (typeof main !== "string" || main.length === 0) throw new Error("Two-stage CDN warming requires a generated Wrangler main module.");
+	return {
+		configPath,
+		main,
+		serverDirectory: path.dirname(configPath)
+	};
+}
+function resolveBuildOutputArtifact(root) {
+	const outputDirectory = path.join(root, ".cloudflare", "output");
+	const configPaths = fs.existsSync(outputDirectory) ? fs.readdirSync(outputDirectory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path.join(outputDirectory, entry.name, "workers", "default", "worker.config.json")).filter((candidate) => fs.existsSync(candidate) && fs.lstatSync(candidate).isFile()) : [];
+	if (configPaths.length !== 1) throw new Error("Two-stage CDN warming requires one default Worker Build Output config under .cloudflare/output/. Rebuild the app before deploying.");
+	const configPath = configPaths[0];
+	let config;
+	try {
+		config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+	} catch (cause) {
+		throw new Error("Two-stage CDN warming could not parse the generated Build Output config.", { cause });
+	}
+	const manifest = config && typeof config === "object" && !Array.isArray(config) ? config.manifest : void 0;
+	const main = manifest && typeof manifest === "object" && !Array.isArray(manifest) ? manifest.mainModule : void 0;
+	if (typeof main !== "string" || main.length === 0) throw new Error("Two-stage CDN warming requires a generated Build Output main module.");
+	return {
+		configPath,
+		main,
+		serverDirectory: path.join(path.dirname(configPath), "bundle")
+	};
+}
+function assertModuleReachable(artifact, moduleName) {
+	const { main, serverDirectory } = artifact;
 	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 (!fs.existsSync(mainPath) || !fs.lstatSync(mainPath).isFile()) throw new Error("Two-stage CDN warming could not find the generated Worker main module.");
 	const viteManifestPath = path.join(serverDirectory, ".vite", "manifest.json");
 	let viteManifest;
 	try {
@@ -155,36 +179,51 @@ function assertManifestModuleReachable(configPath) {
 		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}`;
+			const relativeModule = path.relative(path.dirname(modulePath), path.join(serverDirectory, moduleName)).split(path.sep).join("/");
+			const specifier = relativeModule.startsWith(".") ? relativeModule : `./${relativeModule}`;
 			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}.`);
+	if (!reachable) throw new Error(`Two-stage CDN warming requires the generated Worker graph to statically import ${moduleName}.`);
+}
+function writeStringModule(modulePath, value) {
+	const source = `export default ${JSON.stringify(value)};\n`;
+	const pendingPath = `${modulePath}.${process.pid}.tmp`;
+	try {
+		fs.writeFileSync(pendingPath, source, "utf8");
+		fs.renameSync(pendingPath, modulePath);
+	} finally {
+		if (fs.existsSync(pendingPath)) fs.unlinkSync(pendingPath);
+	}
 }
 /**
 * Write the version-specific manifest into the built Worker artifact.
 * The application build already imports this stable module asset, so the
 * completed dist directory remains the exact input to the final upload.
+*
+* App Router builds also emit the request stage's projection module. It
+* carries the App page routes that can admit a query-free entry, so the
+* request stage can strip the query from those dispatches without loading the
+* full manifest.
 */
-function writeCacheabilityManifestArtifact(root, configuredPath, manifest) {
-	const configPath = resolveGeneratedServerConfig(root, configuredPath);
-	assertManifestModuleReachable(configPath);
-	const serverDirectory = path.dirname(configPath);
+function writeCacheabilityManifestArtifact(root, configuredPath, manifest, deploymentTool = "wrangler") {
+	const artifact = deploymentTool === "cf" ? resolveBuildOutputArtifact(root) : resolveGeneratedWranglerArtifact(root, configuredPath);
+	assertModuleReachable(artifact, CACHEABILITY_MANIFEST_MODULE);
+	const { configPath, serverDirectory } = artifact;
 	const manifestPath = path.join(serverDirectory, CACHEABILITY_MANIFEST_MODULE);
 	if (!fs.existsSync(manifestPath) || !fs.lstatSync(manifestPath).isFile()) throw new Error(`Two-stage CDN warming requires ${CACHEABILITY_MANIFEST_MODULE} in the generated Worker artifact. Rebuild the app before deploying.`);
 	const serializedManifest = JSON.stringify(manifest);
 	const manifestBytes = Buffer.byteLength(serializedManifest);
 	if (manifestBytes > 2097152) throw cacheabilityManifestByteLimitError(manifestBytes);
-	const manifestSource = `export default ${JSON.stringify(serializedManifest)};\n`;
-	const pendingManifestPath = `${manifestPath}.${process.pid}.tmp`;
-	try {
-		fs.writeFileSync(pendingManifestPath, manifestSource, "utf8");
-		fs.renameSync(pendingManifestPath, manifestPath);
-	} finally {
-		if (fs.existsSync(pendingManifestPath)) fs.unlinkSync(pendingManifestPath);
+	const projectionPath = path.join(serverDirectory, CACHEABILITY_REQUEST_PROJECTION_MODULE);
+	const hasProjectionModule = fs.existsSync(projectionPath) && fs.lstatSync(projectionPath).isFile();
+	if (Object.values(manifest.routes).some((route) => route.kind === "app-page")) {
+		if (!hasProjectionModule) throw new Error(`Two-stage CDN warming requires ${CACHEABILITY_REQUEST_PROJECTION_MODULE} in the generated Worker artifact. Rebuild the app before deploying.`);
+		assertModuleReachable(artifact, CACHEABILITY_REQUEST_PROJECTION_MODULE);
 	}
+	writeStringModule(manifestPath, serializedManifest);
+	if (hasProjectionModule) writeStringModule(projectionPath, JSON.stringify(projectCacheabilityManifestForRequestStage(manifest)));
 	return path.relative(root, configPath);
 }
 //#endregion

package/dist/cacheability-probe.d.ts

@@ -32,6 +32,8 @@ export declare function probeStagedWorkerCacheability(options: {
   expectedResponseBuildId?: string;
   fallbackRoutePatterns?: readonly PrerenderRoutePattern[];
   fetchImpl?: typeof fetch;
+  /** App page route patterns with a main-tree loading boundary. */
+  loadingBoundaryRoutePatterns?: readonly string[];
   headers?: HeadersInit;
   retries?: number;
   retryDelayMs?: number;

package/dist/cacheability-probe.js

@@ -30,13 +30,19 @@ function sharedPathPrefix(pathnames) {
 }
 /** 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 ?? [])]);
+	const pathPrefix = sharedPathPrefix([
+		...route.runtimePaths ?? [],
+		...Object.values(route.runtimeRepresentationPaths ?? {}).flatMap((paths) => paths ?? []),
+		...Object.values(route.staticPaths ?? {}).flatMap((paths) => paths ?? [])
+	]);
 	if (!pathPrefix) return route;
+	const compactPathLists = (lists) => Object.fromEntries(Object.entries(lists).map(([representation, paths]) => [representation, paths.map((pathname) => pathname.slice(pathPrefix.length))]));
 	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))])) } : {}
+		...route.runtimeRepresentationPaths ? { runtimeRepresentationPaths: compactPathLists(route.runtimeRepresentationPaths) } : {},
+		...route.staticPaths ? { staticPaths: compactPathLists(route.staticPaths) } : {}
 	};
 	return Buffer.byteLength(JSON.stringify(compacted)) < Buffer.byteLength(JSON.stringify(route)) ? compacted : route;
 }
@@ -261,6 +267,14 @@ async function probeStagedWorkerCacheability(options) {
 		group.targets.push(target);
 		targetGroups.set(concreteKey, group);
 	}
+	const buildTimeListing = /* @__PURE__ */ new Map();
+	const isListedAt = (route, routePathname) => {
+		const key = cacheabilityManifestRouteKey(route.kind, route.pattern);
+		const listed = buildTimeListing.get(`${key}\0${routePathname}`);
+		if (listed !== void 0) return listed;
+		return !/(^|\/):/.test(route.pattern) && normalizeCacheabilityRoutePathname(route.pattern) === routePathname;
+	};
+	const isListedGroup = (group) => isListedAt(group.pattern.route, group.routePathname);
 	const groups = Array.from(targetGroups.values(), (targetGroup) => {
 		targetGroup.targets.sort((first, second) => {
 			return targetPreference(first) - targetPreference(second) || first.sourcePathname.localeCompare(second.sourcePathname);
@@ -270,6 +284,7 @@ async function probeStagedWorkerCacheability(options) {
 			deferred: false,
 			primary: targetGroup.targets[0]
 		};
+		buildTimeListing.set(`${group.pattern.key}\0${group.routePathname}`, group.primary.route.cacheabilityProbe?.unlisted !== true);
 		targetGroup.pattern.groups.push(group);
 		return group;
 	});
@@ -391,12 +406,24 @@ async function probeStagedWorkerCacheability(options) {
 		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) {
+		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.dynamicUsage !== void 0 && result.dynamicUsage !== true || result.explicitConfigCachePolicy !== void 0 && result.explicitConfigCachePolicy !== true || 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" && result.kind === "app-page" && result.status >= 500 && result.reason === `route returned HTTP ${result.status}` && target.route && (result.kind === target.route.kind && result.pattern === target.route.pattern || target.route.cacheabilityProbe?.routeMayResolve === true && result.routePathname !== void 0) && !isListedAt({
+			kind: result.kind,
+			pattern: result.pattern
+		}, result.routePathname === void 0 ? group.routePathname : normalizeCacheabilityRoutePathname(result.routePathname))) {
+			if (target.route.cacheabilityProbe?.routeMayResolve === true && (result.kind !== target.route.kind || result.pattern !== target.route.pattern || result.routePathname !== void 0 && normalizeCacheabilityRoutePathname(result.routePathname) !== group.routePathname)) deferPairedRepresentationsAtOriginalRoute(group);
+			group.dropped = true;
+			if (!group.pattern.groups.some((candidate) => candidate !== group && candidate.resultKey === group.resultKey)) group.pattern.resultKeys.delete(group.resultKey);
+			skippedPathCount += 1;
+			completedPathCount += 1;
+			reportProgress();
+			return "done";
+		}
 		if (result.state === "probe-failed") {
 			failures.push(`${target.label}: ${result.reason ?? "probe failed"}`);
 			completedPathCount += 1;
@@ -432,6 +459,8 @@ async function probeStagedWorkerCacheability(options) {
 		});
 		if (result.routePathname !== void 0) updateGroupRoutePathname(group, result.routePathname);
 		const classification = {
+			dynamicUsage: result.dynamicUsage === true,
+			explicitConfigCachePolicy: result.explicitConfigCachePolicy === true,
 			rendererStatic: result.rendererStatic === true,
 			representation: target.kind,
 			state: result.state,
@@ -439,7 +468,12 @@ async function probeStagedWorkerCacheability(options) {
 		};
 		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);
+		const retainedClassification = !previousClassification || previousClassification.state === "static-candidate" && classification.state === "dynamic" || previousClassification.state === classification.state && previousClassification.rendererStatic && !classification.rendererStatic ? classification : previousClassification;
+		group.pattern.results.set(group.resultKey, {
+			...retainedClassification,
+			dynamicUsage: classification.dynamicUsage || previousClassification?.dynamicUsage === true,
+			explicitConfigCachePolicy: classification.explicitConfigCachePolicy || previousClassification?.explicitConfigCachePolicy === true
+		});
 		if (result.state === "dynamic" && result.scope === "pattern" && group.pattern.canPrune) {
 			group.pattern.pruned = true;
 			dynamicPathCount += 1;
@@ -543,6 +577,7 @@ async function probeStagedWorkerCacheability(options) {
 		classified += 1;
 	}
 	if (limitFailure) throw limitFailure;
+	const loadingBoundaryRoutePatterns = new Set(options.loadingBoundaryRoutePatterns);
 	for (const pattern of patterns.values()) {
 		if (pattern.pruned) {
 			classified += 1;
@@ -562,12 +597,47 @@ async function probeStagedWorkerCacheability(options) {
 			}
 			continue;
 		}
-		if (pattern.results.size === 0 && !pattern.groups.some((group) => group.deferred)) continue;
+		const hasStaticFallback = fallbackRoutes.has(pattern.key);
+		if (pattern.results.size === 0 && !pattern.groups.some((group) => group.deferred)) {
+			if (hasStaticFallback) {
+				const route = {
+					kind: pattern.route.kind,
+					pattern: pattern.route.pattern,
+					state: "static-candidate"
+				};
+				if (!addRouteWithinManifestLimits(pattern.key, route)) break;
+				classified += 1;
+			}
+			continue;
+		}
 		classified += 1;
 		if (Array.from(pattern.results.values()).some((result) => result.state === "dynamic")) dynamic += 1;
+		const isAppPage = pattern.route.kind === "app-page";
+		const listedResults = pattern.groups.flatMap((group) => {
+			const result = !group.deferred && !group.dropped && isListedGroup(group) ? pattern.results.get(group.resultKey) : void 0;
+			return result ? [result] : [];
+		});
+		const hasOnDemandIsr = hasStaticFallback || /(^|\/):/.test(pattern.route.pattern) && listedResults.length > 0 && !listedResults.some((result) => result.dynamicUsage);
+		const hasNoState = (group) => {
+			const result = pattern.results.get(group.resultKey);
+			if (!isAppPage || !result) return false;
+			if (result.state === "static-candidate" && !result.rendererStatic && result.explicitConfigCachePolicy) return false;
+			return result.dynamicUsage || !hasOnDemandIsr && !isListedGroup(group);
+		};
 		const rendererStaticTargets = /* @__PURE__ */ new Map();
 		const runtimePathSet = /* @__PURE__ */ new Set();
+		const loadingShellRuntimePathSet = /* @__PURE__ */ new Set();
 		for (const group of pattern.groups) {
+			if (group.dropped) continue;
+			if (!group.deferred && hasNoState(group)) {
+				const loadingShellTargets = group.targets.filter((target) => target.kind === "rsc-loading-shell");
+				if (loadingShellTargets.length > 0 && pattern.results.get(group.resultKey)?.dynamicUsage && (hasOnDemandIsr || isListedGroup(group))) {
+					loadingShellRuntimePathSet.add(group.routePathname);
+					cacheableTargets.push(...loadingShellTargets);
+					speculativeTargets.push(...loadingShellTargets);
+				}
+				continue;
+			}
 			if (group.deferred) {
 				runtimePathSet.add(group.routePathname);
 				cacheableTargets.push(...group.targets);
@@ -591,26 +661,48 @@ async function probeStagedWorkerCacheability(options) {
 				speculativeTargets.push(...pairedTargets);
 			}
 		}
+		const staticRepresentations = (representation) => isAppPage && representation === "html" ? [
+			"html",
+			"rsc-full",
+			...loadingBoundaryRoutePatterns.has(pattern.route.pattern) ? ["rsc-loading-shell"] : []
+		] : [representation];
 		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 representation of staticRepresentations(staticTarget.kind)) {
+				const paths = staticPaths[representation] ?? [];
+				paths.push(routePathname);
+				staticPaths[representation] = paths;
+			}
 		}
 		for (const paths of Object.values(staticPaths)) paths?.sort();
+		const loadingShellRuntimePaths = Array.from(loadingShellRuntimePathSet).filter((routePathname) => !runtimePathSet.has(routePathname) && !staticPaths["rsc-loading-shell"]?.includes(routePathname)).sort();
+		const runtimeRepresentationPaths = loadingShellRuntimePaths.length > 0 ? { "rsc-loading-shell": loadingShellRuntimePaths } : void 0;
 		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 allowsUnknown = isAppPage ? hasOnDemandIsr : allObservedPathsStaticallyGenerated;
 		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) {
+		if (literalPatternNamesSolePath && !soleGroup.deferred && hasNoState(soleGroup)) {
+			if (!runtimeRepresentationPaths) continue;
+			route = {
+				kind: pattern.route.kind,
+				pattern: pattern.route.pattern,
+				runtimeRepresentation: "rsc-loading-shell",
+				state: "runtime-check"
+			};
+		} else 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 ? {
+			} : result.rendererStatic && isAppPage && result.representation === "html" ? compactManifestRoutePaths({
+				kind: pattern.route.kind,
+				pattern: pattern.route.pattern,
+				state: "runtime-check",
+				staticPaths: Object.fromEntries(staticRepresentations("html").map((representation) => [representation, [soleGroup.routePathname]]))
+			}) : result.rendererStatic ? {
 				kind: pattern.route.kind,
 				pattern: pattern.route.pattern,
 				state: "runtime-check",
@@ -624,15 +716,17 @@ async function probeStagedWorkerCacheability(options) {
 				pattern: pattern.route.pattern,
 				state: "runtime-check"
 			};
-		} else route = compactManifestRoutePaths({
+		} else if (isAppPage && !hasOnDemandIsr && runtimePathSet.size === 0 && !runtimeRepresentationPaths && Object.keys(staticPaths).length === 0) continue;
+		else route = compactManifestRoutePaths({
 			kind: pattern.route.kind,
 			pattern: pattern.route.pattern,
 			state: "runtime-check",
-			...hasStaticFallback || allObservedPathsStaticallyGenerated ? {
+			...hasStaticFallback || allowsUnknown ? {
 				allowUnknown: true,
 				unknownState: "static-candidate"
 			} : {},
 			...runtimePathSet.size > 0 ? { runtimePaths: Array.from(runtimePathSet).sort() } : {},
+			...runtimeRepresentationPaths ? { runtimeRepresentationPaths } : {},
 			...Object.keys(staticPaths).length > 0 ? { staticPaths } : {}
 		});
 		if (!addRouteWithinManifestLimits(pattern.key, route)) break;

package/dist/cdn-warm.d.ts

@@ -80,6 +80,7 @@ export type PrerenderWarmPlan = {
   buildIdentity?: string;
   deploymentId?: string;
   fallbackRoutePatterns?: PrerenderRoutePattern[];
+  loadingBoundaryRoutePatterns?: string[];
   loadingShellPaths: string[];
   pagesDataPaths?: string[];
   pagesPaths?: string[];