fix(cache): gate the middleware Cache Components patch on the app config

Cache interception alone made the generated middleware bundle's shape
build-critical for apps that never render Cache Components routes.

Author: NathanDrake2406

packages/cloudflare/src/cli/build/patches/plugins/cache-components.spec.ts

@@ -256,28 +256,44 @@ ${unrelatedIdleStartCheck}`;
 			`);
 	});
 
-	test("patches cache interception in the generated external middleware", () => {
-		mockFs({
-			"/output/middleware/handler.mjs": `export async function cacheInterceptor(event) {
+	const middlewareBundle = `export async function cacheInterceptor(event) {
   let localizedPath = event.rawPath;
   const isISR = Object.keys(PrerenderManifest?.routes ?? {}).includes(localizedPath);
   if (isISR) {
     return generateResult(event);
   }
   return event;
-}`,
+}`;
+
+	function mockMiddlewareBuild(nextConfig: object, middleware = middlewareBundle) {
+		mockFs({
+			"/app/.next/required-server-files.json": JSON.stringify({ config: nextConfig }),
+			"/output/middleware/handler.mjs": middleware,
 		});
 
-		patchMiddlewareCacheComponents({
+		return {
+			appBuildOutputPath: "/app",
 			outputDir: "/output",
 			config: { dangerous: { enableCacheInterception: true } },
-		} as BuildOptions);
+		} as BuildOptions;
+	}
+
+	test("patches cache interception in the generated external middleware", () => {
+		patchMiddlewareCacheComponents(mockMiddlewareBuild({ cacheComponents: true }));
 
 		expect(readFileSync("/output/middleware/handler.mjs", "utf8")).toContain(
 			'route.renderingMode === "PARTIALLY_STATIC"'
 		);
 	});
 
+	// Cache interception alone must not make the middleware bundle's shape build-critical.
+	test("leaves the middleware alone when the app does not use Cache Components", () => {
+		const buildOpts = mockMiddlewareBuild({}, "export function unrelated() {}");
+
+		expect(() => patchMiddlewareCacheComponents(buildOpts)).not.toThrow();
+		expect(readFileSync("/output/middleware/handler.mjs", "utf8")).toBe("export function unrelated() {}");
+	});
+
 	// The flag moved across Next canaries; missing a spelling would silently skip the patches.
 	test.each([
 		[{ cacheComponents: true }, true],

packages/cloudflare/src/cli/build/patches/plugins/cache-components.ts

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import path from "node:path";
 
+import { loadConfig } from "@opennextjs/aws/adapters/config/util.js";
 import type { BuildOptions } from "@opennextjs/aws/build/helper.js";
 import { patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
 import type { ContentUpdater, Plugin } from "@opennextjs/aws/plugins/content-updater.js";
@@ -112,12 +113,19 @@ export function patchCacheComponentsScheduler(contents: string, runtimePath: str
 /**
  * Cache interception is compiled into the external middleware before the server bundle plugins run,
  * so patch its generated output at the boundary where Cloudflare takes ownership of the AWS build.
+ *
+ * Only apps combining Cache Components with cache interception hit the unresumable shell, so apps
+ * without the flag must not depend on the shape of the generated middleware.
  */
 export function patchMiddlewareCacheComponents(buildOpts: BuildOptions): void {
 	if (buildOpts.config.dangerous?.enableCacheInterception !== true) {
 		return;
 	}
 
+	if (!usesCacheComponents(loadConfig(path.join(buildOpts.appBuildOutputPath, ".next")))) {
+		return;
+	}
+
 	const middlewarePath = path.join(buildOpts.outputDir, "middleware", "handler.mjs");
 	if (!existsSync(middlewarePath)) {
 		throw new Error("Cannot patch cache interception because the middleware bundle is missing");