fix(cloudflare): classify CDN cacheability per concrete route

packages/cloudflare/src/cache/cdn-adapter.runtime.ts

@@ -181,6 +181,7 @@ function formatCacheTag(tags: readonly string[]): string | null {
 
 export class CloudflareCdnCacheAdapter implements CdnCacheAdapter {
   readonly requiresCompletedResponseAdmission = true;
+  readonly responseVary = "verbatim" as const;
 
   constructor(
     private readonly versionMetadata?: WorkerVersionMetadata,

packages/cloudflare/src/cacheability-artifact.ts

@@ -194,16 +194,15 @@ function assertManifestModuleReachable(configPath: string): void {
 }
 
 /**
- * Upload a version-specific manifest from an isolated copy of the built Worker.
- * The application build already imports this stable module asset, so the final
- * upload only replaces its contents and never rewrites generated JavaScript.
+ * 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.
  */
-export function withCacheabilityManifestArtifact<T>(
+export function writeCacheabilityManifestArtifact(
   root: string,
   configuredPath: string | undefined,
   manifest: CacheabilityManifest,
-  upload: (configPath: string) => T,
-): T {
+): string {
   const configPath = resolveGeneratedServerConfig(root, configuredPath);
   assertManifestModuleReachable(configPath);
   const serverDirectory = path.dirname(configPath);
@@ -223,24 +222,13 @@ export function withCacheabilityManifestArtifact<T>(
     throw cacheabilityManifestByteLimitError(manifestBytes);
   }
 
-  const isolatedDirectory = fs.mkdtempSync(
-    path.join(path.dirname(serverDirectory), ".vinext-cache-"),
-  );
+  const manifestSource = `export default ${JSON.stringify(serializedManifest)};\n`;
+  const pendingManifestPath = `${manifestPath}.${process.pid}.tmp`;
   try {
-    fs.cpSync(serverDirectory, isolatedDirectory, { recursive: true });
-    const isolatedManifestPath = path.join(isolatedDirectory, CACHEABILITY_MANIFEST_MODULE);
-    if (!fs.lstatSync(isolatedManifestPath).isFile()) {
-      throw new Error(
-        `Two-stage CDN warming requires ${CACHEABILITY_MANIFEST_MODULE} to be a regular Worker module.`,
-      );
-    }
-    fs.writeFileSync(
-      isolatedManifestPath,
-      `export default ${JSON.stringify(serializedManifest)};\n`,
-      "utf8",
-    );
-    return upload(path.relative(root, path.join(isolatedDirectory, path.basename(configPath))));
+    fs.writeFileSync(pendingManifestPath, manifestSource, "utf8");
+    fs.renameSync(pendingManifestPath, manifestPath);
   } finally {
-    fs.rmSync(isolatedDirectory, { recursive: true, force: true });
+    if (fs.existsSync(pendingManifestPath)) fs.unlinkSync(pendingManifestPath);
   }
+  return path.relative(root, configPath);
 }

packages/cloudflare/src/cacheability-manifest-limits.ts

@@ -6,7 +6,7 @@ export function cacheabilityManifestRouteLimitError(
   limit = MAX_CACHEABILITY_MANIFEST_ROUTES,
 ): Error {
   return new Error(
-    `Two-stage CDN warming produced ${routeCount} cacheable identities; the limit is ${limit}. Narrow prerender discovery or split the deployment before retrying.`,
+    `Two-stage CDN warming produced ${routeCount} cacheable route patterns; the limit is ${limit}. Split the deployment before retrying.`,
   );
 }
 
@@ -15,6 +15,6 @@ export function cacheabilityManifestByteLimitError(
   limit = MAX_CACHEABILITY_MANIFEST_BYTES,
 ): Error {
   return new Error(
-    `Two-stage CDN warming produced a ${manifestBytes}-byte cacheability manifest; the limit is ${limit} bytes. Narrow prerender discovery or split the deployment before retrying.`,
+    `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.`,
   );
 }