@opennextjs/cloudflare 1.6.2 → 1.6.4

package/dist/cli/build/build.js

@@ -63,7 +63,7 @@ export async function build(options, config, projectOpts, wranglerConfig) {
     }
     await createServerBundle(options);
     await compileDurableObjects(options);
-    await bundleServer(options);
+    await bundleServer(options, projectOpts);
     if (!projectOpts.skipWranglerConfigCheck) {
         await createWranglerConfigIfNotExistent(projectOpts);
     }
@@ -74,11 +74,4 @@ function ensureNextjsVersionSupported(options) {
         logger.error("Next.js version unsupported, please upgrade to version 14.2 or greater.");
         process.exit(1);
     }
-    // TODO: remove when 15.4 is supported
-    // Note: `e2e/experimental` is on 15.4.0-canary.14 which works
-    if (!options.appPath.endsWith("opennextjs-cloudflare/examples/e2e/experimental") &&
-        buildHelper.compareSemver(options.nextVersion, ">=", "15.4.0")) {
-        logger.error("Next.js version unsupported, the latest supported version is 15.3");
-        process.exit(1);
-    }
 }

package/dist/cli/build/bundle-server.d.ts

@@ -1,8 +1,9 @@
 import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
+import type { ProjectOptions } from "../project-options.js";
 /**
  * Bundle the Open Next server.
  */
-export declare function bundleServer(buildOpts: BuildOptions): Promise<void>;
+export declare function bundleServer(buildOpts: BuildOptions, projectOpts: ProjectOptions): Promise<void>;
 /**
  * This function apply updates to the bundled code.
  */

package/dist/cli/build/bundle-server.js

@@ -19,6 +19,7 @@ import { patchPagesRouterContext } from "./patches/plugins/pages-router-context.
 import { patchDepdDeprecations } from "./patches/plugins/patch-depd-deprecations.js";
 import { fixRequire } from "./patches/plugins/require.js";
 import { shimRequireHook } from "./patches/plugins/require-hook.js";
+import { patchRouteModules } from "./patches/plugins/route-module.js";
 import { setWranglerExternal } from "./patches/plugins/wrangler-external.js";
 import { copyPackageCliFiles, needsExperimentalReact, normalizePath } from "./utils/index.js";
 /** The dist directory of the Cloudflare adapter package */
@@ -39,7 +40,7 @@ const optionalDependencies = [
 /**
  * Bundle the Open Next server.
  */
-export async function bundleServer(buildOpts) {
+export async function bundleServer(buildOpts, projectOpts) {
     copyPackageCliFiles(packageDistDir, buildOpts);
     const { appPath, outputDir, monorepoRoot, debug } = buildOpts;
     const baseManifestPath = path.join(outputDir, "server-functions/default", getPackagePath(buildOpts), ".next");
@@ -60,9 +61,9 @@ export async function bundleServer(buildOpts) {
         format: "esm",
         target: "esnext",
         // Minify code as much as possible but stay safe by not renaming identifiers
-        minifyWhitespace: !debug,
+        minifyWhitespace: projectOpts.minify && !debug,
         minifyIdentifiers: false,
-        minifySyntax: !debug,
+        minifySyntax: projectOpts.minify && !debug,
         legalComments: "none",
         metafile: true,
         // Next traces files using the default conditions from `nft` (`node`, `require`, `import` and `default`)
@@ -86,6 +87,7 @@ export async function bundleServer(buildOpts) {
             inlineFindDir(updater, buildOpts),
             inlineLoadManifest(updater, buildOpts),
             patchNextServer(updater, buildOpts),
+            patchRouteModules(updater, buildOpts),
             patchDepdDeprecations(updater),
             patchResolveCache(updater, buildOpts),
             // Apply updater updates, must be the last plugin
@@ -124,6 +126,8 @@ export async function bundleServer(buildOpts) {
             "process.env.TURBOPACK": "false",
             // This define should be safe to use for Next 14.2+, earlier versions (13.5 and less) will cause trouble
             "process.env.__NEXT_EXPERIMENTAL_REACT": `${needsExperimentalReact(nextConfig)}`,
+            // Fix `res.validate` in Next 15.4 (together with the `route-module` patch)
+            "process.env.__NEXT_TRUST_HOST_HEADER": "true",
         },
         banner: {
             // We need to import them here, assigning them to `globalThis` does not work because node:timers use `globalThis` and thus create an infinite loop

package/dist/cli/build/patches/plugins/dynamic-requires.js

@@ -37,22 +37,18 @@ function getRequires(idVariable, files, serverDir) {
 export function inlineDynamicRequires(updater, buildOpts) {
     updater.updateContent("inline-node-module-loader", [
         {
-            field: {
-                filter: getCrossPlatformPathRegex(String.raw `/module-loader/node-module-loader\.js$`, {
-                    escape: false,
-                }),
-                contentFilter: /class NodeModuleLoader {/,
-                callback: async ({ contents }) => patchCode(contents, await getNodeModuleLoaderRule(buildOpts)),
-            },
+            filter: getCrossPlatformPathRegex(String.raw `/module-loader/node-module-loader\.js$`, {
+                escape: false,
+            }),
+            contentFilter: /class NodeModuleLoader {/,
+            callback: async ({ contents }) => patchCode(contents, await getNodeModuleLoaderRule(buildOpts)),
         },
     ]);
     updater.updateContent("inline-require-page", [
         {
-            field: {
-                filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/require\.js$`, { escape: false }),
-                contentFilter: /function requirePage\(/,
-                callback: async ({ contents }) => patchCode(contents, await getRequirePageRule(buildOpts)),
-            },
+            filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/require\.js$`, { escape: false }),
+            contentFilter: /function requirePage\(/,
+            callback: async ({ contents }) => patchCode(contents, await getRequirePageRule(buildOpts)),
         },
     ]);
     return { name: "inline-dynamic-requires", setup() { } };

package/dist/cli/build/patches/plugins/find-dir.js

@@ -9,11 +9,9 @@ import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
 export function inlineFindDir(updater, buildOpts) {
     return updater.updateContent("inline-find-dir", [
         {
-            field: {
-                filter: getCrossPlatformPathRegex(String.raw `/next/dist/lib/find-pages-dir\.js$`, { escape: false }),
-                contentFilter: /function findDir\(/,
-                callback: async ({ contents }) => patchCode(contents, await getRule(buildOpts)),
-            },
+            filter: getCrossPlatformPathRegex(String.raw `/next/dist/lib/find-pages-dir\.js$`, { escape: false }),
+            contentFilter: /function findDir\(/,
+            callback: async ({ contents }) => patchCode(contents, await getRule(buildOpts)),
         },
     ]);
 }

package/dist/cli/build/patches/plugins/instrumentation.js

@@ -8,31 +8,25 @@ export function patchInstrumentation(updater, buildOpts) {
     const builtInstrumentationPath = getBuiltInstrumentationPath(buildOpts);
     updater.updateContent("patch-instrumentation-next15-4", [
         {
-            field: {
-                filter: getCrossPlatformPathRegex(String.raw `/server/lib/router-utils/instrumentation-globals.external\.js$`, {
-                    escape: false,
-                }),
-                contentFilter: /getInstrumentationModule\(/,
-                callback: ({ contents }) => patchCode(contents, getNext154Rule(builtInstrumentationPath)),
-            },
+            filter: getCrossPlatformPathRegex(String.raw `/server/lib/router-utils/instrumentation-globals.external\.js$`, {
+                escape: false,
+            }),
+            contentFilter: /getInstrumentationModule\(/,
+            callback: ({ contents }) => patchCode(contents, getNext154Rule(builtInstrumentationPath)),
         },
     ]);
     updater.updateContent("patch-instrumentation-next15", [
         {
-            field: {
-                filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/,
-                contentFilter: /async loadInstrumentationModule\(/,
-                callback: ({ contents }) => patchCode(contents, getNext15Rule(builtInstrumentationPath)),
-            },
+            filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/,
+            contentFilter: /async loadInstrumentationModule\(/,
+            callback: ({ contents }) => patchCode(contents, getNext15Rule(builtInstrumentationPath)),
         },
     ]);
     updater.updateContent("patch-instrumentation-next14", [
         {
-            field: {
-                filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/,
-                contentFilter: /async prepareImpl\(/,
-                callback: ({ contents }) => patchCode(contents, getNext14Rule(builtInstrumentationPath)),
-            },
+            filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/,
+            contentFilter: /async prepareImpl\(/,
+            callback: ({ contents }) => patchCode(contents, getNext14Rule(builtInstrumentationPath)),
         },
     ]);
     return {

package/dist/cli/build/patches/plugins/load-manifest.js

@@ -13,16 +13,14 @@ import { normalizePath } from "../../utils/normalize-path.js";
 export function inlineLoadManifest(updater, buildOpts) {
     return updater.updateContent("inline-load-manifest", [
         {
-            field: {
-                filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/load-manifest(\.external)?\.js$`, {
-                    escape: false,
-                }),
-                contentFilter: /function loadManifest\(/,
-                callback: async ({ contents }) => {
-                    contents = await patchCode(contents, await getLoadManifestRule(buildOpts));
-                    contents = await patchCode(contents, await getEvalManifestRule(buildOpts));
-                    return contents;
-                },
+            filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/load-manifest(\.external)?\.js$`, {
+                escape: false,
+            }),
+            contentFilter: /function loadManifest\(/,
+            callback: async ({ contents }) => {
+                contents = await patchCode(contents, await getLoadManifestRule(buildOpts));
+                contents = await patchCode(contents, await getEvalManifestRule(buildOpts));
+                return contents;
             },
         },
     ]);
@@ -48,8 +46,8 @@ function loadManifest($PATH, $$$ARGS) {
         fix: `
 function loadManifest($PATH, $$$ARGS) {
   $PATH = $PATH.replaceAll(${JSON.stringify(sep)}, ${JSON.stringify(posix.sep)});
-  if ($PATH === "/.next/BUILD_ID") {
-  return process.env.NEXT_BUILD_ID;
+  if ($PATH.endsWith(".next/BUILD_ID")) {
+    return process.env.NEXT_BUILD_ID;
 	}
   ${returnManifests}
   throw new Error(\`Unexpected loadManifest(\${$PATH}) call!\`);

package/dist/cli/build/patches/plugins/next-server.d.ts

@@ -9,6 +9,7 @@
 import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
 import type { ContentUpdater, Plugin } from "@opennextjs/aws/plugins/content-updater.js";
 export declare function patchNextServer(updater: ContentUpdater, buildOpts: BuildOptions): Plugin;
+export declare const disableNodeMiddlewareRule = "\nrule:\n  pattern:\n    selector: method_definition\n    context: \"class { async loadNodeMiddleware($$$PARAMS) { $$$_ } }\"\nfix: |-\n  async loadNodeMiddleware($$$PARAMS) {\n    // patched by open next\n  }\n";
 export declare const buildIdRule = "\nrule:\n  pattern:\n    selector: method_definition\n    context: \"class { getBuildId($$$PARAMS) { $$$_ } }\"\nfix: |-\n  getBuildId($$$PARAMS) {\n    return process.env.NEXT_BUILD_ID;\n  }\n";
 /**
  * The cache handler used by Next.js is normally defined in the config file as a path. At runtime,

package/dist/cli/build/patches/plugins/next-server.js

@@ -14,25 +14,36 @@ import { normalizePath } from "../../utils/index.js";
 export function patchNextServer(updater, buildOpts) {
     return updater.updateContent("next-server", [
         {
-            field: {
-                filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/next-server\.js$`, {
-                    escape: false,
-                }),
-                contentFilter: /getBuildId\(/,
-                callback: async ({ contents }) => {
-                    const { outputDir } = buildOpts;
-                    contents = patchCode(contents, buildIdRule);
-                    const outputPath = path.join(outputDir, "server-functions/default");
-                    const cacheHandler = path.join(outputPath, getPackagePath(buildOpts), "cache.cjs");
-                    contents = patchCode(contents, createCacheHandlerRule(cacheHandler));
-                    const composableCacheHandler = path.join(outputPath, getPackagePath(buildOpts), "composable-cache.cjs");
-                    contents = patchCode(contents, createComposableCacheHandlersRule(composableCacheHandler));
-                    return contents;
-                },
+            filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/next-server\.js$`, {
+                escape: false,
+            }),
+            contentFilter: /getBuildId\(/,
+            callback: async ({ contents }) => {
+                const { outputDir } = buildOpts;
+                contents = patchCode(contents, buildIdRule);
+                const outputPath = path.join(outputDir, "server-functions/default");
+                const cacheHandler = path.join(outputPath, getPackagePath(buildOpts), "cache.cjs");
+                contents = patchCode(contents, createCacheHandlerRule(cacheHandler));
+                const composableCacheHandler = path.join(outputPath, getPackagePath(buildOpts), "composable-cache.cjs");
+                contents = patchCode(contents, createComposableCacheHandlersRule(composableCacheHandler));
+                // Node middleware are not supported on Cloudflare yet
+                contents = patchCode(contents, disableNodeMiddlewareRule);
+                return contents;
             },
         },
     ]);
 }
+// Do not try to load Node middlewares
+export const disableNodeMiddlewareRule = `
+rule:
+  pattern:
+    selector: method_definition
+    context: "class { async loadNodeMiddleware($$$PARAMS) { $$$_ } }"
+fix: |-
+  async loadNodeMiddleware($$$PARAMS) {
+    // patched by open next
+  }
+`;
 export const buildIdRule = `
 rule:
   pattern:

package/dist/cli/build/patches/plugins/open-next.js

@@ -12,14 +12,12 @@ export function patchResolveCache(updater, buildOpts) {
     const indexPath = path.relative(buildOpts.appBuildOutputPath, path.join(outputPath, packagePath, `index.mjs`));
     return updater.updateContent("patch-resolve-cache", [
         {
-            field: {
-                filter: getCrossPlatformPathRegex(indexPath),
-                contentFilter: /cacheHandlerPath/,
-                callback: async ({ contents }) => {
-                    contents = patchCode(contents, cacheHandlerRule);
-                    contents = patchCode(contents, compositeCacheHandlerRule);
-                    return contents;
-                },
+            filter: getCrossPlatformPathRegex(indexPath),
+            contentFilter: /cacheHandlerPath/,
+            callback: async ({ contents }) => {
+                contents = patchCode(contents, cacheHandlerRule);
+                contents = patchCode(contents, compositeCacheHandlerRule);
+                return contents;
             },
         },
     ]);

package/dist/cli/build/patches/plugins/patch-depd-deprecations.js

@@ -8,11 +8,9 @@ import { patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
 export function patchDepdDeprecations(updater) {
     return updater.updateContent("patch-depd-deprecations", [
         {
-            field: {
-                filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/,
-                contentFilter: /argument fn must be a function/,
-                callback: ({ contents }) => patchCode(contents, rule),
-            },
+            filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/,
+            contentFilter: /argument fn must be a function/,
+            callback: ({ contents }) => patchCode(contents, rule),
         },
     ]);
 }

package/dist/cli/build/patches/plugins/require.js

@@ -1,44 +1,42 @@
 export function fixRequire(updater) {
     return updater.updateContent("fix-require", [
         {
-            field: {
-                filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/,
-                contentFilter: /.*/,
-                callback: ({ contents }) => {
-                    // `eval(...)` is not supported by workerd.
-                    contents = contents.replaceAll(`eval("require")`, "require");
-                    // `@opentelemetry` has a few issues.
-                    //
-                    // Next.js has the following code in `next/dist/server/lib/trace/tracer.js`:
-                    //
-                    //     try {
-                    //       api = require('@opentelemetry/api');
-                    //     } catch (err) {
-                    //       api = require('next/dist/compiled/@opentelemetry/api');
-                    //     }
-                    //
-                    // The intent is to allow users to install their own version of `@opentelemetry/api`.
-                    //
-                    // The problem is that even when users do not explicitly install `@opentelemetry/api`,
-                    // `require('@opentelemetry/api')` resolves to the package which is a dependency
-                    // of Next.
-                    //
-                    // The second problem is that when Next traces files, it would not copy the `api/build/esm`
-                    // folder (used by the `module` conditions in package.json) it would only copy `api/build/src`.
-                    // This could be solved by updating the next config:
-                    //
-                    //     const nextConfig: NextConfig = {
-                    //       // ...
-                    //       outputFileTracingIncludes: {
-                    //         "*": ["./node_modules/@opentelemetry/api/build/**/*"],
-                    //       },
-                    //     };
-                    //
-                    // We can consider doing that when we want to enable users to install their own version
-                    // of `@opentelemetry/api`. For now we simply use the pre-compiled version.
-                    contents = contents.replace(/require\(.@opentelemetry\/api.\)/g, `require("next/dist/compiled/@opentelemetry/api")`);
-                    return contents;
-                },
+            filter: /\.(js|mjs|cjs|jsx|ts|tsx)$/,
+            contentFilter: /.*/,
+            callback: ({ contents }) => {
+                // `eval(...)` is not supported by workerd.
+                contents = contents.replaceAll(`eval("require")`, "require");
+                // `@opentelemetry` has a few issues.
+                //
+                // Next.js has the following code in `next/dist/server/lib/trace/tracer.js`:
+                //
+                //     try {
+                //       api = require('@opentelemetry/api');
+                //     } catch (err) {
+                //       api = require('next/dist/compiled/@opentelemetry/api');
+                //     }
+                //
+                // The intent is to allow users to install their own version of `@opentelemetry/api`.
+                //
+                // The problem is that even when users do not explicitly install `@opentelemetry/api`,
+                // `require('@opentelemetry/api')` resolves to the package which is a dependency
+                // of Next.
+                //
+                // The second problem is that when Next traces files, it would not copy the `api/build/esm`
+                // folder (used by the `module` conditions in package.json) it would only copy `api/build/src`.
+                // This could be solved by updating the next config:
+                //
+                //     const nextConfig: NextConfig = {
+                //       // ...
+                //       outputFileTracingIncludes: {
+                //         "*": ["./node_modules/@opentelemetry/api/build/**/*"],
+                //       },
+                //     };
+                //
+                // We can consider doing that when we want to enable users to install their own version
+                // of `@opentelemetry/api`. For now we simply use the pre-compiled version.
+                contents = contents.replace(/require\(.@opentelemetry\/api.\)/g, `require("next/dist/compiled/@opentelemetry/api")`);
+                return contents;
             },
         },
     ]);

package/dist/cli/build/patches/plugins/res-revalidate.js

@@ -65,13 +65,11 @@ export const patchResRevalidate = {
     patches: [
         {
             versions: ">=14.2.0",
-            field: {
-                pathFilter: getCrossPlatformPathRegex(String.raw `(pages-api\.runtime\.prod\.js|node/api-resolver\.js)$`, {
-                    escape: false,
-                }),
-                contentFilter: /\.trustHostHeader/,
-                patchCode: async ({ code }) => patchCode(code, rule),
-            },
+            pathFilter: getCrossPlatformPathRegex(String.raw `(pages-api\.runtime\.prod\.js|node/api-resolver\.js)$`, {
+                escape: false,
+            }),
+            contentFilter: /\.trustHostHeader/,
+            patchCode: async ({ code }) => patchCode(code, rule),
         },
     ],
 };

package/dist/cli/build/patches/plugins/route-module.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Patch for `next/src/server/route-modules/route-module.ts`
+ * https://github.com/vercel/next.js/blob/c8c9bef/packages/next/src/server/route-modules/route-module.ts#L389-L437
+ *
+ * Patch getIncrementalCache to use a string literal for the cache handler path
+ *
+ */
+import { BuildOptions } from "@opennextjs/aws/build/helper.js";
+import type { ContentUpdater, Plugin } from "@opennextjs/aws/plugins/content-updater.js";
+export declare function patchRouteModules(updater: ContentUpdater, buildOpts: BuildOptions): Plugin;
+/**
+ * The cache handler used by Next.js is normally defined in the config file as a path. At runtime,
+ * Next.js would then do a dynamic require on a transformed version of the path to retrieve the
+ * cache handler and create a new instance of it.
+ *
+ * This is problematic in workerd due to the dynamic import of the file that is not known from
+ * build-time. Therefore, we have to manually override the default way that the cache handler is
+ * instantiated with a dynamic require that uses a string literal for the path.
+ */
+export declare function getIncrementalCacheRule(handlerPath: string): string;
+/**
+ * Force trustHostHeader to be true for revalidation
+ */
+export declare const forceTrustHostHeader = "\nrule:\n  pattern: async function $FN($$$ARGS) { $$$BODY }\n  all:\n    - has:\n        pattern: if ($CONTEXT.trustHostHeader) { $$$_ }\n        stopBy: end\n    - has:\n        regex: \"^x-vercel-protection-bypass$\"\n        stopBy: end\n    - has:\n        regex: \"Invariant: missing internal\"\n        stopBy: end\nfix: |-\n    async function $FN($$$ARGS) {\n      $CONTEXT.trustHostHeader = true;\n      $$$BODY\n    }\n";

package/dist/cli/build/patches/plugins/route-module.js

@@ -0,0 +1,77 @@
+/**
+ * Patch for `next/src/server/route-modules/route-module.ts`
+ * https://github.com/vercel/next.js/blob/c8c9bef/packages/next/src/server/route-modules/route-module.ts#L389-L437
+ *
+ * Patch getIncrementalCache to use a string literal for the cache handler path
+ *
+ */
+import path from "node:path";
+import { getPackagePath } from "@opennextjs/aws/build/helper.js";
+import { patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
+import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
+import { normalizePath } from "../../utils/index.js";
+export function patchRouteModules(updater, buildOpts) {
+    return updater.updateContent("route-module", [
+        {
+            filter: getCrossPlatformPathRegex(String.raw `/next/dist/compiled/next-server/.*?\.runtime\.prod\.js$`, {
+                escape: false,
+            }),
+            versions: ">=15.4.0",
+            contentFilter: /getIncrementalCache\(/,
+            callback: async ({ contents }) => {
+                const { outputDir } = buildOpts;
+                const outputPath = path.join(outputDir, "server-functions/default");
+                const cacheHandler = path.join(outputPath, getPackagePath(buildOpts), "cache.cjs");
+                contents = patchCode(contents, getIncrementalCacheRule(cacheHandler));
+                contents = patchCode(contents, forceTrustHostHeader);
+                return contents;
+            },
+        },
+    ]);
+}
+/**
+ * The cache handler used by Next.js is normally defined in the config file as a path. At runtime,
+ * Next.js would then do a dynamic require on a transformed version of the path to retrieve the
+ * cache handler and create a new instance of it.
+ *
+ * This is problematic in workerd due to the dynamic import of the file that is not known from
+ * build-time. Therefore, we have to manually override the default way that the cache handler is
+ * instantiated with a dynamic require that uses a string literal for the path.
+ */
+export function getIncrementalCacheRule(handlerPath) {
+    return `
+rule:
+  pattern: "let $CACHE_HANDLER, { cacheHandler: $HANDLER_PATH } = $C"
+  inside:
+    kind: method_definition
+    has:
+      field: name
+      regex: ^getIncrementalCache$
+    stopBy: end
+fix: |-
+  const $HANDLER_PATH = null;
+  let $CACHE_HANDLER = require('${normalizePath(handlerPath)}').default;
+`;
+}
+/**
+ * Force trustHostHeader to be true for revalidation
+ */
+export const forceTrustHostHeader = `
+rule:
+  pattern: async function $FN($$$ARGS) { $$$BODY }
+  all:
+    - has:
+        pattern: if ($CONTEXT.trustHostHeader) { $$$_ }
+        stopBy: end
+    - has:
+        regex: "^x-vercel-protection-bypass$"
+        stopBy: end
+    - has:
+        regex: "Invariant: missing internal"
+        stopBy: end
+fix: |-
+    async function $FN($$$ARGS) {
+      $CONTEXT.trustHostHeader = true;
+      $$$BODY
+    }
+`;

package/dist/cli/build/patches/plugins/use-cache.js

@@ -28,13 +28,11 @@ export const patchUseCacheIO = {
     patches: [
         {
             versions: ">=15.3.1",
-            field: {
-                pathFilter: getCrossPlatformPathRegex(String.raw `server/app-render/async-local-storage\.js$`, {
-                    escape: false,
-                }),
-                contentFilter: /createSnapshot/,
-                patchCode: async ({ code }) => patchCode(code, rule),
-            },
+            pathFilter: getCrossPlatformPathRegex(String.raw `server/app-render/async-local-storage\.js$`, {
+                escape: false,
+            }),
+            contentFilter: /createSnapshot/,
+            patchCode: async ({ code }) => patchCode(code, rule),
         },
     ],
 };

package/dist/cli/templates/images.d.ts

@@ -26,7 +26,7 @@ export declare function matchLocalPattern(pattern: LocalPattern, url: URL): bool
  * @param buffer The image bytes
  * @returns a content type of undefined for unsupported content
  */
-export declare function detectContentType(buffer: Uint8Array): "image/svg+xml" | "image/jpeg" | "image/png" | "image/gif" | "image/webp" | "image/avif" | "image/x-icon" | "image/x-icns" | "image/tiff" | "image/bmp" | undefined;
+export declare function detectContentType(buffer: Uint8Array): "image/svg+xml" | "image/jpeg" | "image/png" | "image/gif" | "image/webp" | "image/avif" | "image/x-icon" | "image/x-icns" | "image/tiff" | "image/bmp" | "image/jxl" | "image/heic" | "application/pdf" | "image/jp2" | undefined;
 declare global {
     var __IMAGES_REMOTE_PATTERNS__: RemotePattern[];
     var __IMAGES_LOCAL_PATTERNS__: LocalPattern[];

package/dist/cli/templates/images.js

@@ -65,12 +65,15 @@ export async function fetchImage(fetcher, imageUrl, ctx) {
             contentType = detectContentType(value);
         }
         if (!contentType) {
-            // Fallback to the sanitized upstream header when the type can not be detected
+            // Fallback to upstream header when the type can not be detected
             // https://github.com/vercel/next.js/blob/d76f0b1/packages/next/src/server/image-optimizer.ts#L748
-            const header = imgResponse.headers.get("content-type") ?? "";
-            if (header.startsWith("image/") && !header.includes(",")) {
-                contentType = header;
-            }
+            contentType = imgResponse.headers.get("content-type") ?? "";
+        }
+        // Sanitize the content type:
+        // - Accept images only
+        // - Reject multiple content types
+        if (!contentType.startsWith("image/") || contentType.includes(",")) {
+            contentType = undefined;
         }
         if (contentType && !(contentType === SVG && !__IMAGES_ALLOW_SVG__)) {
             const headers = new Headers(imgResponse.headers);
@@ -126,12 +129,17 @@ const AVIF = "image/avif";
 const WEBP = "image/webp";
 const PNG = "image/png";
 const JPEG = "image/jpeg";
+const JXL = "image/jxl";
+const JP2 = "image/jp2";
+const HEIC = "image/heic";
 const GIF = "image/gif";
 const SVG = "image/svg+xml";
 const ICO = "image/x-icon";
 const ICNS = "image/x-icns";
 const TIFF = "image/tiff";
 const BMP = "image/bmp";
+// pdf will be rejected (not an `image/...` type)
+const PDF = "application/pdf";
 /**
  * Detects the content type by looking at the first few bytes of a file
  *
@@ -174,4 +182,19 @@ export function detectContentType(buffer) {
     if ([0x42, 0x4d].every((b, i) => buffer[i] === b)) {
         return BMP;
     }
+    if ([0xff, 0x0a].every((b, i) => buffer[i] === b)) {
+        return JXL;
+    }
+    if ([0x00, 0x00, 0x00, 0x0c, 0x4a, 0x58, 0x4c, 0x20, 0x0d, 0x0a, 0x87, 0x0a].every((b, i) => buffer[i] === b)) {
+        return JXL;
+    }
+    if ([0, 0, 0, 0, 0x66, 0x74, 0x79, 0x70, 0x68, 0x65, 0x69, 0x63].every((b, i) => !b || buffer[i] === b)) {
+        return HEIC;
+    }
+    if ([0x25, 0x50, 0x44, 0x46, 0x2d].every((b, i) => buffer[i] === b)) {
+        return PDF;
+    }
+    if ([0x00, 0x00, 0x00, 0x0c, 0x6a, 0x50, 0x20, 0x20, 0x0d, 0x0a, 0x87, 0x0a].every((b, i) => buffer[i] === b)) {
+        return JP2;
+    }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "1.6.2",
+  "version": "1.6.4",
   "type": "module",
   "bin": {
     "opennextjs-cloudflare": "dist/cli/index.js"
@@ -43,7 +43,7 @@
   "homepage": "https://github.com/opennextjs/opennextjs-cloudflare",
   "dependencies": {
     "@dotenvx/dotenvx": "1.31.0",
-    "@opennextjs/aws": "3.7.1",
+    "@opennextjs/aws": "3.7.4",
     "cloudflare": "^4.4.1",
     "enquirer": "^2.4.1",
     "glob": "^11.0.0",