@opennextjs/cloudflare 1.1.0 → 1.2.1

package/dist/api/config.d.ts

@@ -1,5 +1,5 @@
 import type { BuildOptions } from "@opennextjs/aws/build/helper";
-import { BaseOverride, LazyLoadedOverride, OpenNextConfig as AwsOpenNextConfig } from "@opennextjs/aws/types/open-next";
+import { BaseOverride, LazyLoadedOverride, OpenNextConfig as AwsOpenNextConfig, type RoutePreloadingBehavior } from "@opennextjs/aws/types/open-next";
 import type { CDNInvalidationHandler, IncrementalCache, Queue, TagCache } from "@opennextjs/aws/types/overrides";
 export type Override<T extends BaseOverride> = "dummy" | T | LazyLoadedOverride<T>;
 /**
@@ -30,6 +30,12 @@ export type CloudflareOverrides = {
      * @default false
      */
     enableCacheInterception?: boolean;
+    /**
+     * Route preloading behavior.
+     * Using a value other than "none" can result in higher CPU usage on cold starts.
+     * @default "none"
+     */
+    routePreloadingBehavior?: RoutePreloadingBehavior;
 };
 /**
  * Defines the OpenNext configuration that targets the Cloudflare adapter

package/dist/api/config.js

@@ -5,7 +5,7 @@
  * @returns the OpenNext configuration object
  */
 export function defineCloudflareConfig(config = {}) {
-    const { incrementalCache, tagCache, queue, cachePurge, enableCacheInterception = false } = config;
+    const { incrementalCache, tagCache, queue, cachePurge, enableCacheInterception = false, routePreloadingBehavior = "none", } = config;
     return {
         default: {
             override: {
@@ -17,7 +17,7 @@ export function defineCloudflareConfig(config = {}) {
                 queue: resolveQueue(queue),
                 cdnInvalidation: resolveCdnInvalidation(cachePurge),
             },
-            routePreloadingBehavior: "withWaitUntil",
+            routePreloadingBehavior,
         },
         // node:crypto is used to compute cache keys
         edgeExternals: ["node:crypto"],

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

@@ -6,7 +6,7 @@ export declare function bundleServer(buildOpts: BuildOptions): Promise<void>;
 /**
  * This function applies patches required for the code to run on workers.
  */
-export declare function updateWorkerBundledCode(workerOutputFile: string, buildOpts: BuildOptions): Promise<void>;
+export declare function updateWorkerBundledCode(workerOutputFile: string): Promise<void>;
 /**
  * Gets the path of the worker.js file generated by the build process
  *

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

@@ -9,12 +9,12 @@ import { getOpenNextConfig } from "../../api/config.js";
 import { patchVercelOgLibrary } from "./patches/ast/patch-vercel-og-library.js";
 import { patchWebpackRuntime } from "./patches/ast/webpack-runtime.js";
 import * as patches from "./patches/index.js";
-import { inlineBuildId } from "./patches/plugins/build-id.js";
 import { inlineDynamicRequires } from "./patches/plugins/dynamic-requires.js";
-import { inlineEvalManifest } from "./patches/plugins/eval-manifest.js";
 import { inlineFindDir } from "./patches/plugins/find-dir.js";
 import { patchInstrumentation } from "./patches/plugins/instrumentation.js";
 import { inlineLoadManifest } from "./patches/plugins/load-manifest.js";
+import { patchNextServer } from "./patches/plugins/next-server.js";
+import { patchResolveCache } from "./patches/plugins/open-next.js";
 import { handleOptionalDependencies } from "./patches/plugins/optional-deps.js";
 import { patchPagesRouterContext } from "./patches/plugins/pages-router-context.js";
 import { patchDepdDeprecations } from "./patches/plugins/patch-depd-deprecations.js";
@@ -42,7 +42,7 @@ const optionalDependencies = [
  */
 export async function bundleServer(buildOpts) {
     patches.copyPackageCliFiles(packageDistDir, buildOpts);
-    const { appPath, outputDir, monorepoRoot } = buildOpts;
+    const { appPath, outputDir, monorepoRoot, debug } = buildOpts;
     const baseManifestPath = path.join(outputDir, "server-functions/default", getPackagePath(buildOpts), ".next");
     const serverFiles = path.join(baseManifestPath, "required-server-files.json");
     const nextConfig = JSON.parse(fs.readFileSync(serverFiles, "utf-8")).config;
@@ -60,7 +60,11 @@ export async function bundleServer(buildOpts) {
         outfile: openNextServerBundle,
         format: "esm",
         target: "esnext",
-        minify: false,
+        // Minify code as much as possible but stay safe by not renaming identifiers
+        minifyWhitespace: !debug,
+        minifyIdentifiers: false,
+        minifySyntax: !debug,
+        legalComments: "none",
         metafile: true,
         // Next traces files using the default conditions from `nft` (`node`, `require`, `import` and `default`)
         //
@@ -80,31 +84,28 @@ export async function bundleServer(buildOpts) {
             handleOptionalDependencies(optionalDependencies),
             patchInstrumentation(updater, buildOpts),
             patchPagesRouterContext(buildOpts),
-            inlineEvalManifest(updater, buildOpts),
             inlineFindDir(updater, buildOpts),
             inlineLoadManifest(updater, buildOpts),
-            inlineBuildId(updater),
+            patchNextServer(updater, buildOpts),
             patchDepdDeprecations(updater),
+            patchResolveCache(updater, buildOpts),
             // Apply updater updates, must be the last plugin
             updater.plugin,
         ],
         external: ["./middleware/handler.mjs"],
         alias: {
-            // Note: it looks like node-fetch is actually not necessary for us, so we could replace it with an empty shim
-            //       but just to be safe we replace it with a module that re-exports the native fetch
-            //       we do this to both save on bundle size (there isn't really any benefit in us shipping the node-fetch code)
-            //       and also get rid of a warning in the terminal caused by the package (because it performs an === comparison with -0)
+            // Workers have `fetch` so the `node-fetch` polyfill is not needed
             "next/dist/compiled/node-fetch": path.join(buildOpts.outputDir, "cloudflare-templates/shims/fetch.js"),
-            // Note: we apply an empty shim to next/dist/compiled/ws because it generates two `eval`s:
-            //   eval("require")("bufferutil");
-            //   eval("require")("utf-8-validate");
+            // Workers have builtin Web Sockets
             "next/dist/compiled/ws": path.join(buildOpts.outputDir, "cloudflare-templates/shims/empty.js"),
-            // Note: we apply an empty shim to next/dist/compiled/edge-runtime since (amongst others) it generated the following `eval`:
-            //   eval(getModuleCode)(module, module.exports, throwingRequire, params.context, ...Object.values(params.scopedContext));
-            //   which comes from https://github.com/vercel/edge-runtime/blob/6e96b55f/packages/primitives/src/primitives/load.js#L57-L63
+            // The toolbox optimizer pulls severals MB of dependencies (`caniuse-lite`, `terser`, `acorn`, ...)
+            // Drop it to optimize the code size
+            // See https://github.com/vercel/next.js/blob/6eb235c/packages/next/src/server/optimize-amp.ts
+            "next/dist/compiled/@ampproject/toolbox-optimizer": path.join(buildOpts.outputDir, "cloudflare-templates/shims/throw.js"),
+            // The edge runtime is not supported
             "next/dist/compiled/edge-runtime": path.join(buildOpts.outputDir, "cloudflare-templates/shims/empty.js"),
-            // `@next/env` is a library Next.js uses for loading dotenv files, for obvious reasons we need to stub it here
-            // source: https://github.com/vercel/next.js/tree/0ac10d79720/packages/next-env
+            // `@next/env` is used by Next to load environment variables from files.
+            // OpenNext inlines the values at build time so this is not needed.
             "@next/env": path.join(buildOpts.outputDir, "cloudflare-templates/shims/env.js"),
         },
         define: {
@@ -133,7 +134,7 @@ export async function bundleServer(buildOpts) {
         platform: "node",
     });
     fs.writeFileSync(openNextServerBundle + ".meta.json", JSON.stringify(result.metafile, null, 2));
-    await updateWorkerBundledCode(openNextServerBundle, buildOpts);
+    await updateWorkerBundledCode(openNextServerBundle);
     const isMonorepo = monorepoRoot !== appPath;
     if (isMonorepo) {
         fs.writeFileSync(path.join(outputPath, "handler.mjs"), `export { handler } from "./${normalizePath(packagePath)}/handler.mjs";`);
@@ -143,27 +144,10 @@ export async function bundleServer(buildOpts) {
 /**
  * This function applies patches required for the code to run on workers.
  */
-export async function updateWorkerBundledCode(workerOutputFile, buildOpts) {
+export async function updateWorkerBundledCode(workerOutputFile) {
     const code = await readFile(workerOutputFile, "utf8");
     const patchedCode = await patchCodeWithValidations(code, [
-        ["require", patches.patchRequire],
-        ["cacheHandler", (code) => patches.patchCache(code, buildOpts)],
-        ["composableCache", (code) => patches.patchComposableCache(code, buildOpts), { isOptional: true }],
-        [
-            "'require(this.middlewareManifestPath)'",
-            (code) => patches.inlineMiddlewareManifestRequire(code, buildOpts),
-            { isOptional: true },
-        ],
-        [
-            "`require.resolve` call",
-            // workers do not support dynamic require nor require.resolve
-            (code) => code.replace('require.resolve("./cache.cjs")', '"unused"'),
-        ],
-        [
-            "`require.resolve composable cache` call",
-            // workers do not support dynamic require nor require.resolve
-            (code) => code.replace('require.resolve("./composable-cache.cjs")', '"unused"'),
-        ],
+        ["require", patches.patchRequire, { isOptional: true }],
     ]);
     await writeFile(workerOutputFile, patchedCode);
 }

package/dist/cli/build/open-next/createServerBundle.js

@@ -10,9 +10,7 @@ import { copyMiddlewareResources, generateEdgeBundle } from "@opennextjs/aws/bui
 import * as buildHelper from "@opennextjs/aws/build/helper.js";
 import { installDependencies } from "@opennextjs/aws/build/installDeps.js";
 import { applyCodePatches } from "@opennextjs/aws/build/patch/codePatcher.js";
-import { patchEnvVars, patchFetchCacheForISR, patchFetchCacheSetMissingWaitUntil, patchNextServer, patchUnstableCacheForISR, patchUseCacheForISR, } from "@opennextjs/aws/build/patch/patches/index.js";
-// TODO: import from patches/index.js when https://github.com/opennextjs/opennextjs-aws/pull/827 is released
-import { patchBackgroundRevalidation } from "@opennextjs/aws/build/patch/patches/patchBackgroundRevalidation.js";
+import * as awsPatches from "@opennextjs/aws/build/patch/patches/index.js";
 import logger from "@opennextjs/aws/logger.js";
 import { minifyAll } from "@opennextjs/aws/minimize-js.js";
 import { openNextEdgePlugins } from "@opennextjs/aws/plugins/edge.js";
@@ -133,13 +131,14 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
     }
     const additionalCodePatches = codeCustomization?.additionalCodePatches ?? [];
     await applyCodePatches(options, tracedFiles, manifests, [
-        patchFetchCacheSetMissingWaitUntil,
-        patchFetchCacheForISR,
-        patchUnstableCacheForISR,
-        patchUseCacheForISR,
-        patchNextServer,
-        patchEnvVars,
-        patchBackgroundRevalidation,
+        awsPatches.patchFetchCacheSetMissingWaitUntil,
+        awsPatches.patchFetchCacheForISR,
+        awsPatches.patchUnstableCacheForISR,
+        awsPatches.patchUseCacheForISR,
+        awsPatches.patchNextServer,
+        awsPatches.patchEnvVars,
+        awsPatches.patchBackgroundRevalidation,
+        awsPatches.patchDropBabel,
         // Cloudflare specific patches
         patchResRevalidate,
         patchUseCacheIO,

package/dist/cli/build/patches/index.d.ts

@@ -1,2 +1 @@
 export * from "./investigated/index.js";
-export * from "./to-investigate/inline-middleware-manifest.js";

package/dist/cli/build/patches/index.js

@@ -1,2 +1 @@
 export * from "./investigated/index.js";
-export * from "./to-investigate/inline-middleware-manifest.js";

package/dist/cli/build/patches/investigated/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./copy-package-cli-files.js";
-export * from "./patch-cache.js";
 export * from "./patch-require.js";

package/dist/cli/build/patches/investigated/index.js

@@ -1,3 +1,2 @@
 export * from "./copy-package-cli-files.js";
-export * from "./patch-cache.js";
 export * from "./patch-require.js";

package/dist/cli/build/patches/plugins/load-manifest.d.ts

@@ -1,5 +1,7 @@
 /**
- * Inline `loadManifest` as it relies on `readFileSync` that is not supported by workerd.
+ * Inline `loadManifest` and `evalManifest` from `load-manifest.js`
+ *
+ * They rely on `readFileSync` that is not supported by workerd.
  */
 import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
 import type { ContentUpdater, Plugin } from "@opennextjs/aws/plugins/content-updater.js";

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

@@ -1,5 +1,7 @@
 /**
- * Inline `loadManifest` as it relies on `readFileSync` that is not supported by workerd.
+ * Inline `loadManifest` and `evalManifest` from `load-manifest.js`
+ *
+ * They rely on `readFileSync` that is not supported by workerd.
  */
 import { readFile } from "node:fs/promises";
 import { join, posix, relative, sep } from "node:path";
@@ -16,21 +18,24 @@ export function inlineLoadManifest(updater, buildOpts) {
                     escape: false,
                 }),
                 contentFilter: /function loadManifest\(/,
-                callback: async ({ contents }) => patchCode(contents, await getRule(buildOpts)),
+                callback: async ({ contents }) => {
+                    contents = await patchCode(contents, await getLoadManifestRule(buildOpts));
+                    contents = await patchCode(contents, await getEvalManifestRule(buildOpts));
+                    return contents;
+                },
             },
         },
     ]);
 }
-async function getRule(buildOpts) {
+async function getLoadManifestRule(buildOpts) {
     const { outputDir } = buildOpts;
     const baseDir = join(outputDir, "server-functions/default", getPackagePath(buildOpts));
     const dotNextDir = join(baseDir, ".next");
     const manifests = await glob(join(dotNextDir, "**/*-manifest.json"), { windowsPathsNoEscape: true });
     const returnManifests = (await Promise.all(manifests.map(async (manifest) => `
-            if ($PATH.endsWith("${normalizePath("/" + relative(dotNextDir, manifest))}")) {
-              return ${await readFile(manifest, "utf-8")};
-            }
-          `))).join("\n");
+if ($PATH.endsWith("${normalizePath("/" + relative(dotNextDir, manifest))}")) {
+  return ${await readFile(manifest, "utf-8")};
+}`))).join("\n");
     return {
         rule: {
             pattern: `
@@ -46,3 +51,40 @@ function loadManifest($PATH, $$$ARGS) {
 }`,
     };
 }
+async function getEvalManifestRule(buildOpts) {
+    const { outputDir } = buildOpts;
+    const baseDir = join(outputDir, "server-functions/default", getPackagePath(buildOpts), ".next");
+    const appDir = join(baseDir, "server/app");
+    const manifests = await glob(join(baseDir, "**/*_client-reference-manifest.js"), {
+        windowsPathsNoEscape: true,
+    });
+    const returnManifests = manifests
+        .map((manifest) => {
+        const endsWith = normalizePath(relative(baseDir, manifest));
+        const key = normalizePath("/" + relative(appDir, manifest)).replace("_client-reference-manifest.js", "");
+        return `
+if ($PATH.endsWith("${endsWith}")) {
+  require(${JSON.stringify(manifest)});
+  return {
+    __RSC_MANIFEST: {
+    "${key}": globalThis.__RSC_MANIFEST["${key}"],
+    },
+  };
+}`;
+    })
+        .join("\n");
+    return {
+        rule: {
+            pattern: `
+function evalManifest($PATH, $$$ARGS) {
+  $$$_
+}`,
+        },
+        fix: `
+function evalManifest($PATH, $$$ARGS) {
+  $PATH = $PATH.replaceAll(${JSON.stringify(sep)}, ${JSON.stringify(posix.sep)});
+  ${returnManifests}
+  throw new Error(\`Unexpected evalManifest(\${$PATH}) call!\`);
+}`,
+    };
+}

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

@@ -0,0 +1,25 @@
+/**
+ * Misc patches for `next-server.js`
+ *
+ * Note: we will probably need to revisit the patches when the Next adapter API lands
+ *
+ * - Inline `getBuildId` as it relies on `readFileSync` that is not supported by workerd
+ * - Inline the middleware manifest
+ * - Override the cache and composable cache handlers
+ */
+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 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";
+export declare function createMiddlewareManifestRule(manifest: unknown): string;
+/**
+ * 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 createCacheHandlerRule(handlerPath: string): string;
+export declare function createComposableCacheHandlersRule(handlerPath: string): string;

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

@@ -0,0 +1,110 @@
+/**
+ * Misc patches for `next-server.js`
+ *
+ * Note: we will probably need to revisit the patches when the Next adapter API lands
+ *
+ * - Inline `getBuildId` as it relies on `readFileSync` that is not supported by workerd
+ * - Inline the middleware manifest
+ * - Override the cache and composable cache handlers
+ */
+import { existsSync, readFileSync } from "node:fs";
+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 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 manifestPath = path.join(outputDir, "server-functions/default", getPackagePath(buildOpts), ".next/server/middleware-manifest.json");
+                    const manifest = existsSync(manifestPath)
+                        ? JSON.parse(await readFileSync(manifestPath, "utf-8"))
+                        : {};
+                    contents = patchCode(contents, createMiddlewareManifestRule(manifest));
+                    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;
+                },
+            },
+        },
+    ]);
+}
+export const buildIdRule = `
+rule:
+  pattern:
+    selector: method_definition
+    context: "class { getBuildId($$$PARAMS) { $$$_ } }"
+fix: |-
+  getBuildId($$$PARAMS) {
+    return process.env.NEXT_BUILD_ID;
+  }
+`;
+export function createMiddlewareManifestRule(manifest) {
+    return `
+rule:
+  pattern:
+    selector: method_definition
+    context: "class { getMiddlewareManifest($$$PARAMS) { $$$_ } }"
+fix: |-
+  getMiddlewareManifest($$$PARAMS) {
+    return ${JSON.stringify(manifest)};
+  }
+`;
+}
+/**
+ * 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 createCacheHandlerRule(handlerPath) {
+    return `
+rule:
+  pattern: "const { cacheHandler } = this.nextConfig;"
+  inside:
+    kind: method_definition
+    has:
+      field: name
+      regex: ^getIncrementalCache$
+    stopBy: end
+
+fix: |-
+  const cacheHandler = null;
+  CacheHandler = require('${normalizePath(handlerPath)}').default;
+`;
+}
+export function createComposableCacheHandlersRule(handlerPath) {
+    return `
+rule:
+  pattern: "const { cacheHandlers } = this.nextConfig.experimental;"
+  inside:
+    kind: method_definition
+    has:
+      field: name
+      regex: ^loadCustomCacheHandlers$
+    stopBy: end
+
+fix: |-
+  const cacheHandlers = null;
+  const handlersSymbol = Symbol.for('@next/cache-handlers');
+  const handlersMapSymbol = Symbol.for('@next/cache-handlers-map');
+  const handlersSetSymbol = Symbol.for('@next/cache-handlers-set');
+  globalThis[handlersMapSymbol] = new Map();
+  globalThis[handlersMapSymbol].set("default", require('${normalizePath(handlerPath)}').default);
+  globalThis[handlersSetSymbol] = new Set(globalThis[handlersMapSymbol].values());
+`;
+}

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

@@ -0,0 +1,429 @@
+import { patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
+import { describe, expect, test } from "vitest";
+import { buildIdRule, createCacheHandlerRule, createComposableCacheHandlersRule, createMiddlewareManifestRule, } from "./next-server.js";
+describe("Next Server", () => {
+    const nextServerCode = `
+class NextNodeServer extends _baseserver.default {
+    constructor(options){
+        // Initialize super class
+        super(options);
+        this.handleNextImageRequest = async (req, res, parsedUrl) => { /* ... */ };
+    }
+    async handleUpgrade() {
+    // The web server does not support web sockets, it's only used for HMR in
+    // development.
+    }
+    loadEnvConfig({ dev, forceReload, silent }) {
+        (0, _env.loadEnvConfig)(this.dir, dev, silent ? {
+            info: ()=>{},
+            error: ()=>{}
+        } : _log, forceReload);
+    }
+    async hasPage(pathname) {
+        var _this_nextConfig_i18n;
+        return !!(0, _require.getMaybePagePath)(pathname, this.distDir, (_this_nextConfig_i18n = this.nextConfig.i18n) == null ? void 0 : _this_nextConfig_i18n.locales, this.enabledDirectories.app);
+    }
+    getBuildId() {
+        const buildIdFile = (0, _path.join)(this.distDir, _constants.BUILD_ID_FILE);
+        try {
+            return _fs.default.readFileSync(buildIdFile, "utf8").trim();
+        } catch (err) {
+            if (err.code === "ENOENT") {
+                throw new Error(\`Could not find a production build in the '\${this.distDir}' directory. Try building your app with 'next build' before starting the production server. https://nextjs.org/docs/messages/production-start-no-build-id\`);
+            }
+            throw err;
+        }
+    }
+    getMiddlewareManifest() {
+        if (this.minimalMode) return null;
+        const manifest = require(this.middlewareManifestPath);
+        return manifest;
+    }
+    async loadCustomCacheHandlers() {
+        const { cacheHandlers } = this.nextConfig.experimental;
+        if (!cacheHandlers) return;
+        // If we've already initialized the cache handlers interface, don't do it
+        // again.
+        if (!(0, _handlers.initializeCacheHandlers)()) return;
+        for (const [kind, handler] of Object.entries(cacheHandlers)){
+            if (!handler) continue;
+            (0, _handlers.setCacheHandler)(kind, (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, handler))));
+        }
+    }
+    async getIncrementalCache({ requestHeaders, requestProtocol }) {
+        const dev = !!this.renderOpts.dev;
+        let CacheHandler;
+        const { cacheHandler } = this.nextConfig;
+        if (cacheHandler) {
+            CacheHandler = (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, cacheHandler)));
+        }
+        await this.loadCustomCacheHandlers();
+        // incremental-cache is request specific
+        // although can have shared caches in module scope
+        // per-cache handler
+        return new _incrementalcache.IncrementalCache({
+            fs: this.getCacheFilesystem(),
+            dev,
+            requestHeaders,
+            requestProtocol,
+            allowedRevalidateHeaderKeys: this.nextConfig.experimental.allowedRevalidateHeaderKeys,
+            minimalMode: this.minimalMode,
+            serverDistDir: this.serverDistDir,
+            fetchCacheKeyPrefix: this.nextConfig.experimental.fetchCacheKeyPrefix,
+            maxMemoryCacheSize: this.nextConfig.cacheMaxMemorySize,
+            flushToDisk: !this.minimalMode && this.nextConfig.experimental.isrFlushToDisk,
+            getPrerenderManifest: ()=>this.getPrerenderManifest(),
+            CurCacheHandler: CacheHandler
+        });
+    }
+    getEnabledDirectories(dev) {
+        const dir = dev ? this.dir : this.serverDistDir;
+        return {
+            app: (0, _findpagesdir.findDir)(dir, "app") ? true : false,
+            pages: (0, _findpagesdir.findDir)(dir, "pages") ? true : false
+        };
+    }
+    // ...
+}`;
+    test("build ID", () => {
+        expect(patchCode(nextServerCode, buildIdRule)).toMatchInlineSnapshot(`
+        "class NextNodeServer extends _baseserver.default {
+            constructor(options){
+                // Initialize super class
+                super(options);
+                this.handleNextImageRequest = async (req, res, parsedUrl) => { /* ... */ };
+            }
+            async handleUpgrade() {
+            // The web server does not support web sockets, it's only used for HMR in
+            // development.
+            }
+            loadEnvConfig({ dev, forceReload, silent }) {
+                (0, _env.loadEnvConfig)(this.dir, dev, silent ? {
+                    info: ()=>{},
+                    error: ()=>{}
+                } : _log, forceReload);
+            }
+            async hasPage(pathname) {
+                var _this_nextConfig_i18n;
+                return !!(0, _require.getMaybePagePath)(pathname, this.distDir, (_this_nextConfig_i18n = this.nextConfig.i18n) == null ? void 0 : _this_nextConfig_i18n.locales, this.enabledDirectories.app);
+            }
+            getBuildId() {
+          return process.env.NEXT_BUILD_ID;
+        }
+            getMiddlewareManifest() {
+                if (this.minimalMode) return null;
+                const manifest = require(this.middlewareManifestPath);
+                return manifest;
+            }
+            async loadCustomCacheHandlers() {
+                const { cacheHandlers } = this.nextConfig.experimental;
+                if (!cacheHandlers) return;
+                // If we've already initialized the cache handlers interface, don't do it
+                // again.
+                if (!(0, _handlers.initializeCacheHandlers)()) return;
+                for (const [kind, handler] of Object.entries(cacheHandlers)){
+                    if (!handler) continue;
+                    (0, _handlers.setCacheHandler)(kind, (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, handler))));
+                }
+            }
+            async getIncrementalCache({ requestHeaders, requestProtocol }) {
+                const dev = !!this.renderOpts.dev;
+                let CacheHandler;
+                const { cacheHandler } = this.nextConfig;
+                if (cacheHandler) {
+                    CacheHandler = (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, cacheHandler)));
+                }
+                await this.loadCustomCacheHandlers();
+                // incremental-cache is request specific
+                // although can have shared caches in module scope
+                // per-cache handler
+                return new _incrementalcache.IncrementalCache({
+                    fs: this.getCacheFilesystem(),
+                    dev,
+                    requestHeaders,
+                    requestProtocol,
+                    allowedRevalidateHeaderKeys: this.nextConfig.experimental.allowedRevalidateHeaderKeys,
+                    minimalMode: this.minimalMode,
+                    serverDistDir: this.serverDistDir,
+                    fetchCacheKeyPrefix: this.nextConfig.experimental.fetchCacheKeyPrefix,
+                    maxMemoryCacheSize: this.nextConfig.cacheMaxMemorySize,
+                    flushToDisk: !this.minimalMode && this.nextConfig.experimental.isrFlushToDisk,
+                    getPrerenderManifest: ()=>this.getPrerenderManifest(),
+                    CurCacheHandler: CacheHandler
+                });
+            }
+            getEnabledDirectories(dev) {
+                const dir = dev ? this.dir : this.serverDistDir;
+                return {
+                    app: (0, _findpagesdir.findDir)(dir, "app") ? true : false,
+                    pages: (0, _findpagesdir.findDir)(dir, "pages") ? true : false
+                };
+            }
+            // ...
+        }"
+      `);
+    });
+    test("middleware manifest", () => {
+        expect(patchCode(nextServerCode, createMiddlewareManifestRule("manifest"))).toMatchInlineSnapshot(`
+      "class NextNodeServer extends _baseserver.default {
+          constructor(options){
+              // Initialize super class
+              super(options);
+              this.handleNextImageRequest = async (req, res, parsedUrl) => { /* ... */ };
+          }
+          async handleUpgrade() {
+          // The web server does not support web sockets, it's only used for HMR in
+          // development.
+          }
+          loadEnvConfig({ dev, forceReload, silent }) {
+              (0, _env.loadEnvConfig)(this.dir, dev, silent ? {
+                  info: ()=>{},
+                  error: ()=>{}
+              } : _log, forceReload);
+          }
+          async hasPage(pathname) {
+              var _this_nextConfig_i18n;
+              return !!(0, _require.getMaybePagePath)(pathname, this.distDir, (_this_nextConfig_i18n = this.nextConfig.i18n) == null ? void 0 : _this_nextConfig_i18n.locales, this.enabledDirectories.app);
+          }
+          getBuildId() {
+              const buildIdFile = (0, _path.join)(this.distDir, _constants.BUILD_ID_FILE);
+              try {
+                  return _fs.default.readFileSync(buildIdFile, "utf8").trim();
+              } catch (err) {
+                  if (err.code === "ENOENT") {
+                      throw new Error(\`Could not find a production build in the '\${this.distDir}' directory. Try building your app with 'next build' before starting the production server. https://nextjs.org/docs/messages/production-start-no-build-id\`);
+                  }
+                  throw err;
+              }
+          }
+          getMiddlewareManifest() {
+        return "manifest";
+      }
+          async loadCustomCacheHandlers() {
+              const { cacheHandlers } = this.nextConfig.experimental;
+              if (!cacheHandlers) return;
+              // If we've already initialized the cache handlers interface, don't do it
+              // again.
+              if (!(0, _handlers.initializeCacheHandlers)()) return;
+              for (const [kind, handler] of Object.entries(cacheHandlers)){
+                  if (!handler) continue;
+                  (0, _handlers.setCacheHandler)(kind, (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, handler))));
+              }
+          }
+          async getIncrementalCache({ requestHeaders, requestProtocol }) {
+              const dev = !!this.renderOpts.dev;
+              let CacheHandler;
+              const { cacheHandler } = this.nextConfig;
+              if (cacheHandler) {
+                  CacheHandler = (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, cacheHandler)));
+              }
+              await this.loadCustomCacheHandlers();
+              // incremental-cache is request specific
+              // although can have shared caches in module scope
+              // per-cache handler
+              return new _incrementalcache.IncrementalCache({
+                  fs: this.getCacheFilesystem(),
+                  dev,
+                  requestHeaders,
+                  requestProtocol,
+                  allowedRevalidateHeaderKeys: this.nextConfig.experimental.allowedRevalidateHeaderKeys,
+                  minimalMode: this.minimalMode,
+                  serverDistDir: this.serverDistDir,
+                  fetchCacheKeyPrefix: this.nextConfig.experimental.fetchCacheKeyPrefix,
+                  maxMemoryCacheSize: this.nextConfig.cacheMaxMemorySize,
+                  flushToDisk: !this.minimalMode && this.nextConfig.experimental.isrFlushToDisk,
+                  getPrerenderManifest: ()=>this.getPrerenderManifest(),
+                  CurCacheHandler: CacheHandler
+              });
+          }
+          getEnabledDirectories(dev) {
+              const dir = dev ? this.dir : this.serverDistDir;
+              return {
+                  app: (0, _findpagesdir.findDir)(dir, "app") ? true : false,
+                  pages: (0, _findpagesdir.findDir)(dir, "pages") ? true : false
+              };
+          }
+          // ...
+      }"
+    `);
+    });
+    test("cache handler", () => {
+        expect(patchCode(nextServerCode, createCacheHandlerRule("manifest"))).toMatchInlineSnapshot(`
+      "class NextNodeServer extends _baseserver.default {
+          constructor(options){
+              // Initialize super class
+              super(options);
+              this.handleNextImageRequest = async (req, res, parsedUrl) => { /* ... */ };
+          }
+          async handleUpgrade() {
+          // The web server does not support web sockets, it's only used for HMR in
+          // development.
+          }
+          loadEnvConfig({ dev, forceReload, silent }) {
+              (0, _env.loadEnvConfig)(this.dir, dev, silent ? {
+                  info: ()=>{},
+                  error: ()=>{}
+              } : _log, forceReload);
+          }
+          async hasPage(pathname) {
+              var _this_nextConfig_i18n;
+              return !!(0, _require.getMaybePagePath)(pathname, this.distDir, (_this_nextConfig_i18n = this.nextConfig.i18n) == null ? void 0 : _this_nextConfig_i18n.locales, this.enabledDirectories.app);
+          }
+          getBuildId() {
+              const buildIdFile = (0, _path.join)(this.distDir, _constants.BUILD_ID_FILE);
+              try {
+                  return _fs.default.readFileSync(buildIdFile, "utf8").trim();
+              } catch (err) {
+                  if (err.code === "ENOENT") {
+                      throw new Error(\`Could not find a production build in the '\${this.distDir}' directory. Try building your app with 'next build' before starting the production server. https://nextjs.org/docs/messages/production-start-no-build-id\`);
+                  }
+                  throw err;
+              }
+          }
+          getMiddlewareManifest() {
+              if (this.minimalMode) return null;
+              const manifest = require(this.middlewareManifestPath);
+              return manifest;
+          }
+          async loadCustomCacheHandlers() {
+              const { cacheHandlers } = this.nextConfig.experimental;
+              if (!cacheHandlers) return;
+              // If we've already initialized the cache handlers interface, don't do it
+              // again.
+              if (!(0, _handlers.initializeCacheHandlers)()) return;
+              for (const [kind, handler] of Object.entries(cacheHandlers)){
+                  if (!handler) continue;
+                  (0, _handlers.setCacheHandler)(kind, (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, handler))));
+              }
+          }
+          async getIncrementalCache({ requestHeaders, requestProtocol }) {
+              const dev = !!this.renderOpts.dev;
+              let CacheHandler;
+              const cacheHandler = null;
+      CacheHandler = require('manifest').default;
+              if (cacheHandler) {
+                  CacheHandler = (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, cacheHandler)));
+              }
+              await this.loadCustomCacheHandlers();
+              // incremental-cache is request specific
+              // although can have shared caches in module scope
+              // per-cache handler
+              return new _incrementalcache.IncrementalCache({
+                  fs: this.getCacheFilesystem(),
+                  dev,
+                  requestHeaders,
+                  requestProtocol,
+                  allowedRevalidateHeaderKeys: this.nextConfig.experimental.allowedRevalidateHeaderKeys,
+                  minimalMode: this.minimalMode,
+                  serverDistDir: this.serverDistDir,
+                  fetchCacheKeyPrefix: this.nextConfig.experimental.fetchCacheKeyPrefix,
+                  maxMemoryCacheSize: this.nextConfig.cacheMaxMemorySize,
+                  flushToDisk: !this.minimalMode && this.nextConfig.experimental.isrFlushToDisk,
+                  getPrerenderManifest: ()=>this.getPrerenderManifest(),
+                  CurCacheHandler: CacheHandler
+              });
+          }
+          getEnabledDirectories(dev) {
+              const dir = dev ? this.dir : this.serverDistDir;
+              return {
+                  app: (0, _findpagesdir.findDir)(dir, "app") ? true : false,
+                  pages: (0, _findpagesdir.findDir)(dir, "pages") ? true : false
+              };
+          }
+          // ...
+      }"
+    `);
+    });
+    test("composable cache handler", () => {
+        expect(patchCode(nextServerCode, createComposableCacheHandlersRule("manifest"))).toMatchInlineSnapshot(`
+      "class NextNodeServer extends _baseserver.default {
+          constructor(options){
+              // Initialize super class
+              super(options);
+              this.handleNextImageRequest = async (req, res, parsedUrl) => { /* ... */ };
+          }
+          async handleUpgrade() {
+          // The web server does not support web sockets, it's only used for HMR in
+          // development.
+          }
+          loadEnvConfig({ dev, forceReload, silent }) {
+              (0, _env.loadEnvConfig)(this.dir, dev, silent ? {
+                  info: ()=>{},
+                  error: ()=>{}
+              } : _log, forceReload);
+          }
+          async hasPage(pathname) {
+              var _this_nextConfig_i18n;
+              return !!(0, _require.getMaybePagePath)(pathname, this.distDir, (_this_nextConfig_i18n = this.nextConfig.i18n) == null ? void 0 : _this_nextConfig_i18n.locales, this.enabledDirectories.app);
+          }
+          getBuildId() {
+              const buildIdFile = (0, _path.join)(this.distDir, _constants.BUILD_ID_FILE);
+              try {
+                  return _fs.default.readFileSync(buildIdFile, "utf8").trim();
+              } catch (err) {
+                  if (err.code === "ENOENT") {
+                      throw new Error(\`Could not find a production build in the '\${this.distDir}' directory. Try building your app with 'next build' before starting the production server. https://nextjs.org/docs/messages/production-start-no-build-id\`);
+                  }
+                  throw err;
+              }
+          }
+          getMiddlewareManifest() {
+              if (this.minimalMode) return null;
+              const manifest = require(this.middlewareManifestPath);
+              return manifest;
+          }
+          async loadCustomCacheHandlers() {
+              const cacheHandlers = null;
+      const handlersSymbol = Symbol.for('@next/cache-handlers');
+      const handlersMapSymbol = Symbol.for('@next/cache-handlers-map');
+      const handlersSetSymbol = Symbol.for('@next/cache-handlers-set');
+      globalThis[handlersMapSymbol] = new Map();
+      globalThis[handlersMapSymbol].set("default", require('manifest').default);
+      globalThis[handlersSetSymbol] = new Set(globalThis[handlersMapSymbol].values());
+              if (!cacheHandlers) return;
+              // If we've already initialized the cache handlers interface, don't do it
+              // again.
+              if (!(0, _handlers.initializeCacheHandlers)()) return;
+              for (const [kind, handler] of Object.entries(cacheHandlers)){
+                  if (!handler) continue;
+                  (0, _handlers.setCacheHandler)(kind, (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, handler))));
+              }
+          }
+          async getIncrementalCache({ requestHeaders, requestProtocol }) {
+              const dev = !!this.renderOpts.dev;
+              let CacheHandler;
+              const { cacheHandler } = this.nextConfig;
+              if (cacheHandler) {
+                  CacheHandler = (0, _interopdefault.interopDefault)(await dynamicImportEsmDefault((0, _formatdynamicimportpath.formatDynamicImportPath)(this.distDir, cacheHandler)));
+              }
+              await this.loadCustomCacheHandlers();
+              // incremental-cache is request specific
+              // although can have shared caches in module scope
+              // per-cache handler
+              return new _incrementalcache.IncrementalCache({
+                  fs: this.getCacheFilesystem(),
+                  dev,
+                  requestHeaders,
+                  requestProtocol,
+                  allowedRevalidateHeaderKeys: this.nextConfig.experimental.allowedRevalidateHeaderKeys,
+                  minimalMode: this.minimalMode,
+                  serverDistDir: this.serverDistDir,
+                  fetchCacheKeyPrefix: this.nextConfig.experimental.fetchCacheKeyPrefix,
+                  maxMemoryCacheSize: this.nextConfig.cacheMaxMemorySize,
+                  flushToDisk: !this.minimalMode && this.nextConfig.experimental.isrFlushToDisk,
+                  getPrerenderManifest: ()=>this.getPrerenderManifest(),
+                  CurCacheHandler: CacheHandler
+              });
+          }
+          getEnabledDirectories(dev) {
+              const dir = dev ? this.dir : this.serverDistDir;
+              return {
+                  app: (0, _findpagesdir.findDir)(dir, "app") ? true : false,
+                  pages: (0, _findpagesdir.findDir)(dir, "pages") ? true : false
+              };
+          }
+          // ...
+      }"
+    `);
+    });
+});

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

@@ -0,0 +1,8 @@
+/**
+ * Removed unused `require.resolve` calls in Open Next.
+ */
+import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
+import type { ContentUpdater, Plugin } from "@opennextjs/aws/plugins/content-updater.js";
+export declare function patchResolveCache(updater: ContentUpdater, buildOpts: BuildOptions): Plugin;
+export declare const cacheHandlerRule = "\nrule:\n  pattern: var cacheHandlerPath = __require.resolve(\"./cache.cjs\");\nfix: |-\n  var cacheHandlerPath = \"\";\n";
+export declare const compositeCacheHandlerRule = "\nrule:\n  pattern: var composableCacheHandlerPath = __require.resolve(\"./composable-cache.cjs\");\nfix: |-\n  var composableCacheHandlerPath = \"\";\n";

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

@@ -0,0 +1,38 @@
+/**
+ * Removed unused `require.resolve` calls in Open Next.
+ */
+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";
+export function patchResolveCache(updater, buildOpts) {
+    const { outputDir } = buildOpts;
+    const packagePath = getPackagePath(buildOpts);
+    const outputPath = path.join(outputDir, "server-functions/default");
+    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;
+                },
+            },
+        },
+    ]);
+}
+export const cacheHandlerRule = `
+rule:
+  pattern: var cacheHandlerPath = __require.resolve("./cache.cjs");
+fix: |-
+  var cacheHandlerPath = "";
+`;
+export const compositeCacheHandlerRule = `
+rule:
+  pattern: var composableCacheHandlerPath = __require.resolve("./composable-cache.cjs");
+fix: |-
+  var composableCacheHandlerPath = "";
+`;

package/dist/cli/build/utils/apply-patches.js

@@ -18,6 +18,5 @@ export async function patchCodeWithValidations(code, patches) {
             throw new Error(`Failed to patch ${target}`);
         }
     }
-    console.log(`All ${patches.length} patches applied\n`);
     return patchedCode;
 }

package/dist/cli/templates/init.js

@@ -108,5 +108,10 @@ function populateProcessEnv(url, env) {
             port: url.port,
         },
     });
+    /* We need to set this environment variable to make redirects work properly in preview mode.
+     * Next sets this in standalone mode during `startServer`. Without this the protocol would always be `https` here:
+     * https://github.com/vercel/next.js/blob/6b1e48080e896e0d44a05fe009cb79d2d3f91774/packages/next/src/server/app-render/action-handler.ts#L307-L316
+     */
+    process.env.__NEXT_PRIVATE_ORIGIN = url.origin;
 }
 /* eslint-enable no-var */

package/dist/cli/templates/shims/throw.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/cli/templates/shims/throw.js

@@ -0,0 +1,2 @@
+throw "OpenNext shim";
+export default {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "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.6.4",
+    "@opennextjs/aws": "3.6.5",
     "enquirer": "^2.4.1",
     "glob": "^11.0.0",
     "ts-tqdm": "^0.8.6"
@@ -68,7 +68,7 @@
     "vitest": "^2.1.1"
   },
   "peerDependencies": {
-    "wrangler": "^4.14.0"
+    "wrangler": "^4.19.1"
   },
   "scripts": {
     "clean": "rimraf dist",

package/dist/cli/build/patches/investigated/patch-cache.d.ts

@@ -1,14 +0,0 @@
-import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
-/**
- * Sets up the OpenNext cache handler in a Next.js build.
- *
- * 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 patchCache(code: string, buildOpts: BuildOptions): Promise<string>;
-export declare function patchComposableCache(code: string, buildOpts: BuildOptions): Promise<string>;

package/dist/cli/build/patches/investigated/patch-cache.js

@@ -1,40 +0,0 @@
-import path from "node:path";
-import { getPackagePath } from "@opennextjs/aws/build/helper.js";
-import { normalizePath } from "../../utils/index.js";
-/**
- * Sets up the OpenNext cache handler in a Next.js build.
- *
- * 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 async function patchCache(code, buildOpts) {
-    const { outputDir } = buildOpts;
-    // TODO: switch to cache.mjs
-    const outputPath = path.join(outputDir, "server-functions/default");
-    const cacheFile = path.join(outputPath, getPackagePath(buildOpts), "cache.cjs");
-    return code.replace("const { cacheHandler } = this.nextConfig;", `
-const cacheHandler = null;
-CacheHandler = require('${normalizePath(cacheFile)}').default;
-`);
-}
-export async function patchComposableCache(code, buildOpts) {
-    const { outputDir } = buildOpts;
-    // TODO: switch to mjs
-    const outputPath = path.join(outputDir, "server-functions/default");
-    const cacheFile = path.join(outputPath, getPackagePath(buildOpts), "composable-cache.cjs");
-    //TODO: Do we want to move this to the new CodePatcher ?
-    return code.replace("const { cacheHandlers } = this.nextConfig.experimental", `
-const cacheHandlers = null;
-const handlersSymbol = Symbol.for('@next/cache-handlers');
-const handlersMapSymbol = Symbol.for('@next/cache-handlers-map');
-const handlersSetSymbol = Symbol.for('@next/cache-handlers-set');
-globalThis[handlersMapSymbol] = new Map();
-globalThis[handlersMapSymbol].set("default", require('${normalizePath(cacheFile)}').default);
-globalThis[handlersSetSymbol] = new Set(globalThis[handlersMapSymbol].values());
-`);
-}

package/dist/cli/build/patches/plugins/build-id.d.ts

@@ -1,6 +0,0 @@
-/**
- * Inline `getBuildId` as it relies on `readFileSync` that is not supported by workerd.
- */
-import type { ContentUpdater, Plugin } from "@opennextjs/aws/plugins/content-updater.js";
-export declare function inlineBuildId(updater: ContentUpdater): Plugin;
-export declare const rule = "\nrule:\n  kind: method_definition\n  has:\n    field: name\n    regex: ^getBuildId$\nfix: |-\n  getBuildId() {\n    return process.env.NEXT_BUILD_ID;\n  }\n";

package/dist/cli/build/patches/plugins/build-id.js

@@ -1,29 +0,0 @@
-/**
- * Inline `getBuildId` as it relies on `readFileSync` that is not supported by workerd.
- */
-import { patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
-import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
-export function inlineBuildId(updater) {
-    return updater.updateContent("inline-build-id", [
-        {
-            field: {
-                filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/next-server\.js$`, {
-                    escape: false,
-                }),
-                contentFilter: /getBuildId\(/,
-                callback: ({ contents }) => patchCode(contents, rule),
-            },
-        },
-    ]);
-}
-export const rule = `
-rule:
-  kind: method_definition
-  has:
-    field: name
-    regex: ^getBuildId$
-fix: |-
-  getBuildId() {
-    return process.env.NEXT_BUILD_ID;
-  }
-`;

package/dist/cli/build/patches/plugins/build-id.spec.js

@@ -1,82 +0,0 @@
-import { patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
-import { describe, expect, test } from "vitest";
-import { rule } from "./build-id.js";
-describe("getBuildId", () => {
-    test("patch", () => {
-        const code = `
-class NextNodeServer extends _baseserver.default {
-    constructor(options){
-        // Initialize super class
-        super(options);
-        this.handleNextImageRequest = async (req, res, parsedUrl) => { /* ... */ };
-    }
-    async handleUpgrade() {
-    // The web server does not support web sockets, it's only used for HMR in
-    // development.
-    }
-    loadEnvConfig({ dev, forceReload, silent }) {
-        (0, _env.loadEnvConfig)(this.dir, dev, silent ? {
-            info: ()=>{},
-            error: ()=>{}
-        } : _log, forceReload);
-    }
-    async hasPage(pathname) {
-        var _this_nextConfig_i18n;
-        return !!(0, _require.getMaybePagePath)(pathname, this.distDir, (_this_nextConfig_i18n = this.nextConfig.i18n) == null ? void 0 : _this_nextConfig_i18n.locales, this.enabledDirectories.app);
-    }
-    getBuildId() {
-        const buildIdFile = (0, _path.join)(this.distDir, _constants.BUILD_ID_FILE);
-        try {
-            return _fs.default.readFileSync(buildIdFile, "utf8").trim();
-        } catch (err) {
-            if (err.code === "ENOENT") {
-                throw new Error(\`Could not find a production build in the '\${this.distDir}' directory. Try building your app with 'next build' before starting the production server. https://nextjs.org/docs/messages/production-start-no-build-id\`);
-            }
-            throw err;
-        }
-    }
-    getEnabledDirectories(dev) {
-        const dir = dev ? this.dir : this.serverDistDir;
-        return {
-            app: (0, _findpagesdir.findDir)(dir, "app") ? true : false,
-            pages: (0, _findpagesdir.findDir)(dir, "pages") ? true : false
-        };
-    }
-    // ...
-}`;
-        expect(patchCode(code, rule)).toMatchInlineSnapshot(`
-      "class NextNodeServer extends _baseserver.default {
-          constructor(options){
-              // Initialize super class
-              super(options);
-              this.handleNextImageRequest = async (req, res, parsedUrl) => { /* ... */ };
-          }
-          async handleUpgrade() {
-          // The web server does not support web sockets, it's only used for HMR in
-          // development.
-          }
-          loadEnvConfig({ dev, forceReload, silent }) {
-              (0, _env.loadEnvConfig)(this.dir, dev, silent ? {
-                  info: ()=>{},
-                  error: ()=>{}
-              } : _log, forceReload);
-          }
-          async hasPage(pathname) {
-              var _this_nextConfig_i18n;
-              return !!(0, _require.getMaybePagePath)(pathname, this.distDir, (_this_nextConfig_i18n = this.nextConfig.i18n) == null ? void 0 : _this_nextConfig_i18n.locales, this.enabledDirectories.app);
-          }
-          getBuildId() {
-        return process.env.NEXT_BUILD_ID;
-      }
-          getEnabledDirectories(dev) {
-              const dir = dev ? this.dir : this.serverDistDir;
-              return {
-                  app: (0, _findpagesdir.findDir)(dir, "app") ? true : false,
-                  pages: (0, _findpagesdir.findDir)(dir, "pages") ? true : false
-              };
-          }
-          // ...
-      }"
-    `);
-    });
-});

package/dist/cli/build/patches/plugins/eval-manifest.d.ts

@@ -1,7 +0,0 @@
-/**
- * Inline `evalManifest` as it relies on `readFileSync` and `runInNewContext`
- * that are not supported by workerd.
- */
-import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
-import type { ContentUpdater, Plugin } from "@opennextjs/aws/plugins/content-updater.js";
-export declare function inlineEvalManifest(updater: ContentUpdater, buildOpts: BuildOptions): Plugin;

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

@@ -1,61 +0,0 @@
-/**
- * Inline `evalManifest` as it relies on `readFileSync` and `runInNewContext`
- * that are not supported by workerd.
- */
-import { join, posix, relative, sep } 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 { glob } from "glob";
-import { normalizePath } from "../../utils/normalize-path.js";
-export function inlineEvalManifest(updater, buildOpts) {
-    return updater.updateContent("inline-eval-manifest", [
-        {
-            field: {
-                filter: getCrossPlatformPathRegex(String.raw `/next/dist/server/load-manifest(\.external)?\.js$`, {
-                    escape: false,
-                }),
-                contentFilter: /function evalManifest\(/,
-                callback: async ({ contents }) => patchCode(contents, await getRule(buildOpts)),
-            },
-        },
-    ]);
-}
-async function getRule(buildOpts) {
-    const { outputDir } = buildOpts;
-    const baseDir = join(outputDir, "server-functions/default", getPackagePath(buildOpts), ".next");
-    const appDir = join(baseDir, "server/app");
-    const manifests = await glob(join(baseDir, "**/*_client-reference-manifest.js"), {
-        windowsPathsNoEscape: true,
-    });
-    const returnManifests = manifests
-        .map((manifest) => {
-        const endsWith = normalizePath(relative(baseDir, manifest));
-        const key = normalizePath("/" + relative(appDir, manifest)).replace("_client-reference-manifest.js", "");
-        return `
-          if ($PATH.endsWith("${endsWith}")) {
-            require(${JSON.stringify(manifest)});
-            return {
-              __RSC_MANIFEST: {
-              "${key}": globalThis.__RSC_MANIFEST["${key}"],
-              },
-            };
-          }
-        `;
-    })
-        .join("\n");
-    return {
-        rule: {
-            pattern: `
-function evalManifest($PATH, $$$ARGS) {
-  $$$_
-}`,
-        },
-        fix: `
-function evalManifest($PATH, $$$ARGS) {
-  $PATH = $PATH.replaceAll(${JSON.stringify(sep)}, ${JSON.stringify(posix.sep)});
-  ${returnManifests}
-  throw new Error(\`Unexpected evalManifest(\${$PATH}) call!\`);
-}`,
-    };
-}

package/dist/cli/build/patches/to-investigate/inline-middleware-manifest.d.ts

@@ -1,6 +0,0 @@
-import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
-/**
- * Inlines the middleware manifest from the build output to prevent a dynamic require statement
- * as they result in runtime failures.
- */
-export declare function inlineMiddlewareManifestRequire(code: string, buildOpts: BuildOptions): string;

package/dist/cli/build/patches/to-investigate/inline-middleware-manifest.js

@@ -1,15 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { getPackagePath } from "@opennextjs/aws/build/helper.js";
-/**
- * Inlines the middleware manifest from the build output to prevent a dynamic require statement
- * as they result in runtime failures.
- */
-export function inlineMiddlewareManifestRequire(code, buildOpts) {
-    const { outputDir } = buildOpts;
-    const middlewareManifestPath = join(outputDir, "server-functions/default", getPackagePath(buildOpts), ".next/server/middleware-manifest.json");
-    const middlewareManifest = existsSync(middlewareManifestPath)
-        ? JSON.parse(readFileSync(middlewareManifestPath, "utf-8"))
-        : {};
-    return code.replace("require(this.middlewareManifestPath)", JSON.stringify(middlewareManifest));
-}