@opennextjs/cloudflare 0.3.10 → 0.4.1

package/README.md

@@ -6,70 +6,7 @@ Deploy Next.js apps to Cloudflare!
 
 ## Get started
 
-You can use [`create-next-app`](https://nextjs.org/docs/pages/api-reference/cli/create-next-app) to start a new application or take an existing Next.js application and deploy it to Cloudflare using the following few steps:
-
-## Configure your app
-
-- add the following `devDependencies` to the `package.json`:
-
-  ```bash
-  npm add -D wrangler@latest @opennextjs/cloudflare
-  # or
-  pnpm add -D wrangler@latest @opennextjs/cloudflare
-  # or
-  yarn add -D wrangler@latest @opennextjs/cloudflare
-  # or
-  bun add -D wrangler@latest @opennextjs/cloudflare
-  ```
-
-- add a `wrangler.toml` at the root of your project
-
-  ```toml
-  #:schema node_modules/wrangler/config-schema.json
-  name = "<your-app-name>"
-  main = ".open-next/worker.js"
-
-  compatibility_date = "2024-09-23"
-  compatibility_flags = ["nodejs_compat"]
-
-  # Use the new Workers + Assets to host the static frontend files
-  assets = { directory = ".open-next/assets", binding = "ASSETS" }
-  ```
-
-- add a `open-next.config.ts` at the root of your project:
-
-```ts
-import type { OpenNextConfig } from "open-next/types/open-next";
-
-const config: OpenNextConfig = {
-  default: {
-    override: {
-      wrapper: "cloudflare-node",
-      converter: "edge",
-      // Unused implementation
-      incrementalCache: "dummy",
-      tagCache: "dummy",
-      queue: "dummy",
-    },
-  },
-
-  middleware: {
-    external: true,
-    override: {
-      wrapper: "cloudflare-edge",
-      converter: "edge",
-      proxyExternalRequest: "fetch",
-    },
-  },
-};
-
-export default config;
-```
-
-## Known issues
-
-- `▲ [WARNING] Suspicious assignment to defined constant "process.env.NODE_ENV" [assign-to-define]` can safely be ignored
-- Maybe more, still experimental...
+To get started with the adapter visit the [official get started documentation](https://opennext.js.org/cloudflare/get-started).
 
 ## Local development
 

package/dist/api/{get-cloudflare-context.d.ts → cloudflare-context.d.ts}

@@ -23,4 +23,11 @@ export type CloudflareContext<CfProperties extends Record<string, unknown> = Inc
  *
  * @returns the cloudflare context
  */
-export declare function getCloudflareContext<CfProperties extends Record<string, unknown> = IncomingRequestCfProperties, Context = ExecutionContext>(): Promise<CloudflareContext<CfProperties, Context>>;
+export declare function getCloudflareContext<CfProperties extends Record<string, unknown> = IncomingRequestCfProperties, Context = ExecutionContext>(): CloudflareContext<CfProperties, Context>;
+/**
+ * Performs some initial setup to integrate as best as possible the local Next.js dev server (run via `next dev`)
+ * with the open-next Cloudflare adapter
+ *
+ * Note: this function should only be called inside the Next.js config file, and although async it doesn't need to be `await`ed
+ */
+export declare function initOpenNextCloudflareForDev(): Promise<void>;

package/dist/api/cloudflare-context.js

@@ -0,0 +1,114 @@
+/**
+ * Symbol used as an index in the global scope to set and retrieve the Cloudflare context
+ *
+ * This is used both in production (in the actual built worker) and in development (`next dev`)
+ *
+ * Note: this symbol needs to be kept in sync with the one used in `src/cli/templates/worker.ts`
+ */
+const cloudflareContextSymbol = Symbol.for("__cloudflare-context__");
+/**
+ * Utility to get the current Cloudflare context
+ *
+ * @returns the cloudflare context
+ */
+export function getCloudflareContext() {
+    const global = globalThis;
+    const cloudflareContext = global[cloudflareContextSymbol];
+    if (!cloudflareContext) {
+        // the cloudflare context is initialized by the worker and is always present in production/preview
+        // during local development (`next dev`) it might be missing only if the developers hasn't called
+        // the `initOpenNextCloudflareForDev` function in their Next.js config file
+        const getContextFunctionName = getCloudflareContext.name;
+        const initFunctionName = initOpenNextCloudflareForDev.name;
+        throw new Error(`\n\n\`${getContextFunctionName}\` has been called during development without having called` +
+            ` the \`${initFunctionName}\` function inside the Next.js config file.\n\n` +
+            `In order to use \`${getContextFunctionName}\` import and call ${initFunctionName} in the Next.js config file.\n\n` +
+            "Example: \n   ```\n   // next.config.mjs\n\n" +
+            `   import { ${initFunctionName} } from "@opennextjs/cloudflare";\n\n` +
+            `   ${initFunctionName}();\n\n` +
+            "   /** @type {import('next').NextConfig} */\n" +
+            "   const nextConfig = {};\n" +
+            "   export default nextConfig;\n" +
+            "   ```\n" +
+            "\n(note: currently middlewares in Next.js are always run using the edge runtime)\n\n");
+    }
+    return cloudflareContext;
+}
+/**
+ * Performs some initial setup to integrate as best as possible the local Next.js dev server (run via `next dev`)
+ * with the open-next Cloudflare adapter
+ *
+ * Note: this function should only be called inside the Next.js config file, and although async it doesn't need to be `await`ed
+ */
+export async function initOpenNextCloudflareForDev() {
+    const shouldInitializationRun = shouldContextInitializationRun();
+    if (!shouldInitializationRun)
+        return;
+    const context = await getCloudflareContextFromWrangler();
+    addCloudflareContextToNodejsGlobal(context);
+    await monkeyPatchVmModuleEdgeContext(context);
+}
+/**
+ * Next dev server imports the config file twice (in two different processes, making it hard to track),
+ * this causes the initialization to run twice as well, to keep things clean, not allocate extra
+ * resources (i.e. instantiate two miniflare instances) and avoid extra potential logs, it would be best
+ * to run the initialization only once, this function is used to try to make it so that it does, it returns
+ * a flag which indicates if the initialization should run in the current process or not.
+ *
+ * @returns boolean indicating if the initialization should run
+ */
+function shouldContextInitializationRun() {
+    // via debugging we've seen that AsyncLocalStorage is only set in one of the
+    // two processes so we're using it as the differentiator between the two
+    const AsyncLocalStorage = globalThis["AsyncLocalStorage"];
+    return !!AsyncLocalStorage;
+}
+/**
+ * Adds the cloudflare context to the global scope in which the Next.js dev node.js process runs in, enabling
+ * future calls to `getCloudflareContext` to retrieve and return such context
+ *
+ * @param cloudflareContext the cloudflare context to add to the node.sj global scope
+ */
+function addCloudflareContextToNodejsGlobal(cloudflareContext) {
+    const global = globalThis;
+    global[cloudflareContextSymbol] = cloudflareContext;
+}
+/**
+ * Next.js uses the Node.js vm module's `runInContext()` function to evaluate edge functions
+ * in a runtime context that tries to simulate as accurately as possible the actual production runtime
+ * behavior, see: https://github.com/vercel/next.js/blob/9a1cd3/packages/next/src/server/web/sandbox/context.ts#L525-L527
+ *
+ * This function monkey-patches the Node.js `vm` module to override the `runInContext()` function so that the
+ * cloudflare context is added to the runtime context's global scope before edge functions are evaluated
+ *
+ * @param cloudflareContext the cloudflare context to patch onto the "edge" runtime context global scope
+ */
+async function monkeyPatchVmModuleEdgeContext(cloudflareContext) {
+    const require = (await import(/* webpackIgnore: true */ `${"__module".replaceAll("_", "")}`)).default.createRequire(import.meta.url);
+    // eslint-disable-next-line unicorn/prefer-node-protocol -- the `next dev` compiler doesn't accept the node prefix
+    const vmModule = require("vm");
+    const originalRunInContext = vmModule.runInContext.bind(vmModule);
+    vmModule.runInContext = (code, contextifiedObject, options) => {
+        const runtimeContext = contextifiedObject;
+        runtimeContext[cloudflareContextSymbol] ??= cloudflareContext;
+        return originalRunInContext(code, contextifiedObject, options);
+    };
+}
+/**
+ * Gets a cloudflare context object from wrangler
+ *
+ * @returns the cloudflare context ready for use
+ */
+async function getCloudflareContextFromWrangler() {
+    // Note: we never want wrangler to be bundled in the Next.js app, that's why the import below looks like it does
+    const { getPlatformProxy } = await import(/* webpackIgnore: true */ `${"__wrangler".replaceAll("_", "")}`);
+    const { env, cf, ctx } = await getPlatformProxy({
+        // This allows the selection of a wrangler environment while running in next dev mode
+        environment: process.env.NEXT_DEV_WRANGLER_ENV,
+    });
+    return {
+        env,
+        cf: cf,
+        ctx: ctx,
+    };
+}

package/dist/api/index.d.ts

@@ -1 +1 @@
-export * from "./get-cloudflare-context.js";
+export * from "./cloudflare-context.js";

package/dist/api/index.js

@@ -1 +1 @@
-export * from "./get-cloudflare-context.js";
+export * from "./cloudflare-context.js";

package/dist/api/kvCache.d.ts

@@ -1,4 +1,3 @@
-import type { KVNamespace } from "@cloudflare/workers-types";
 import type { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides";
 export declare const CACHE_ASSET_DIR = "cnd-cgi/_next_cache";
 export declare const STATUS_DELETED = 1;
@@ -11,9 +10,6 @@ export declare const STATUS_DELETED = 1;
  */
 declare class Cache implements IncrementalCache {
     readonly name = "cloudflare-kv";
-    protected initialized: boolean;
-    protected kv: KVNamespace | undefined;
-    protected assets: Fetcher | undefined;
     get<IsFetch extends boolean = false>(key: string, isFetch?: IsFetch): Promise<WithLastModified<CacheValue<IsFetch>>>;
     set<IsFetch extends boolean = false>(key: string, value: CacheValue<IsFetch>, isFetch?: IsFetch): Promise<void>;
     delete(key: string): Promise<void>;
@@ -21,7 +17,6 @@ declare class Cache implements IncrementalCache {
     protected getAssetUrl(key: string, isFetch?: boolean): string;
     protected debug(...args: unknown[]): void;
     protected getBuildId(): string;
-    protected init(): Promise<void>;
 }
 declare const _default: Cache;
 export default _default;

package/dist/api/kvCache.js

@@ -1,5 +1,5 @@
 import { IgnorableError, RecoverableError } from "@opennextjs/aws/utils/error.js";
-import { getCloudflareContext } from "./get-cloudflare-context.js";
+import { getCloudflareContext } from "./cloudflare-context.js";
 export const CACHE_ASSET_DIR = "cnd-cgi/_next_cache";
 export const STATUS_DELETED = 1;
 /**
@@ -11,31 +11,28 @@ export const STATUS_DELETED = 1;
  */
 class Cache {
     name = "cloudflare-kv";
-    initialized = false;
-    kv;
-    assets;
     async get(key, isFetch) {
-        if (!this.initialized) {
-            await this.init();
-        }
-        if (!(this.kv || this.assets)) {
+        const cfEnv = getCloudflareContext().env;
+        const kv = cfEnv.NEXT_CACHE_WORKERS_KV;
+        const assets = cfEnv.ASSETS;
+        if (!(kv || assets)) {
             throw new IgnorableError(`No KVNamespace nor Fetcher`);
         }
         this.debug(`Get ${key}`);
         try {
             let entry = null;
-            if (this.kv) {
+            if (kv) {
                 this.debug(`- From KV`);
                 const kvKey = this.getKVKey(key, isFetch);
-                entry = await this.kv.get(kvKey, "json");
+                entry = await kv.get(kvKey, "json");
                 if (entry?.status === STATUS_DELETED) {
                     return {};
                 }
             }
-            if (!entry && this.assets) {
+            if (!entry && assets) {
                 this.debug(`- From Assets`);
                 const url = this.getAssetUrl(key, isFetch);
-                const response = await this.assets.fetch(url);
+                const response = await assets.fetch(url);
                 if (response.ok) {
                     // TODO: consider populating KV with the asset value if faster.
                     // This could be optional as KV writes are $$.
@@ -55,10 +52,8 @@ class Cache {
         }
     }
     async set(key, value, isFetch) {
-        if (!this.initialized) {
-            await this.init();
-        }
-        if (!this.kv) {
+        const kv = getCloudflareContext().env.NEXT_CACHE_WORKERS_KV;
+        if (!kv) {
             throw new IgnorableError(`No KVNamespace`);
         }
         this.debug(`Set ${key}`);
@@ -67,7 +62,7 @@ class Cache {
             // Note: We can not set a TTL as we might fallback to assets,
             //       still removing old data (old BUILD_ID) could help avoiding
             //       the cache growing too big.
-            await this.kv.put(kvKey, JSON.stringify({
+            await kv.put(kvKey, JSON.stringify({
                 value,
                 // Note: `Date.now()` returns the time of the last IO rather than the actual time.
                 //       See https://developers.cloudflare.com/workers/reference/security-model/
@@ -79,17 +74,15 @@ class Cache {
         }
     }
     async delete(key) {
-        if (!this.initialized) {
-            await this.init();
-        }
-        if (!this.kv) {
+        const kv = getCloudflareContext().env.NEXT_CACHE_WORKERS_KV;
+        if (!kv) {
             throw new IgnorableError(`No KVNamespace`);
         }
         this.debug(`Delete ${key}`);
         try {
             const kvKey = this.getKVKey(key, /* isFetch= */ false);
             // Do not delete the key as we would then fallback to the assets.
-            await this.kv.put(kvKey, JSON.stringify({ status: STATUS_DELETED }));
+            await kv.put(kvKey, JSON.stringify({ status: STATUS_DELETED }));
         }
         catch {
             throw new RecoverableError(`Failed to delete cache [${key}]`);
@@ -111,11 +104,5 @@ class Cache {
     getBuildId() {
         return process.env.NEXT_BUILD_ID ?? "no-build-id";
     }
-    async init() {
-        const env = (await getCloudflareContext()).env;
-        this.kv = env.NEXT_CACHE_WORKERS_KV;
-        this.assets = env.ASSETS;
-        this.initialized = true;
-    }
 }
 export default new Cache();

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

@@ -1,4 +1,4 @@
-import type { ProjectOptions } from "../config.js";
+import type { ProjectOptions } from "../project-options.js";
 /**
  * Builds the application in a format that can be passed to workerd
  *

package/dist/cli/build/build.js

@@ -1,6 +1,5 @@
-import { cpSync } from "node:fs";
 import { createRequire } from "node:module";
-import { dirname, join } from "node:path";
+import { dirname } from "node:path";
 import { buildNextjsApp, setStandaloneBuildMode } from "@opennextjs/aws/build/buildNextApp.js";
 import { compileCache } from "@opennextjs/aws/build/compileCache.js";
 import { compileOpenNextConfig } from "@opennextjs/aws/build/compileConfig.js";
@@ -9,7 +8,6 @@ import { createMiddleware } from "@opennextjs/aws/build/createMiddleware.js";
 import * as buildHelper from "@opennextjs/aws/build/helper.js";
 import { printHeader, showWarningOnWindows } from "@opennextjs/aws/build/utils.js";
 import logger from "@opennextjs/aws/logger.js";
-import { containsDotNextDir, getConfig } from "../config.js";
 import { bundleServer } from "./bundle-server.js";
 import { compileEnvFiles } from "./open-next/compile-env-files.js";
 import { copyCacheAssets } from "./open-next/copyCacheAssets.js";
@@ -52,9 +50,6 @@ export async function build(projectOpts) {
         setStandaloneBuildMode(options);
         buildNextjsApp(options);
     }
-    if (!containsDotNextDir(projectOpts.sourceDir)) {
-        throw new Error(`.next folder not found in ${projectOpts.sourceDir}`);
-    }
     // Generate deployable bundle
     printHeader("Generating bundle");
     buildHelper.initOutputDir(options);
@@ -70,12 +65,7 @@ export async function build(projectOpts) {
         copyCacheAssets(options);
     }
     await createServerBundle(options);
-    // TODO: drop this copy.
-    // Copy the .next directory to the output directory so it can be mutated.
-    cpSync(join(projectOpts.sourceDir, ".next"), join(projectOpts.outputDir, ".next"), { recursive: true });
-    const projConfig = getConfig(projectOpts);
-    // TODO: rely on options only.
-    await bundleServer(projConfig, options);
+    await bundleServer(options);
     if (!projectOpts.skipWranglerConfigCheck) {
         await createWranglerConfigIfNotExistent(projectOpts);
     }

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

@@ -1,13 +1,12 @@
-import type { BuildOptions } from "@opennextjs/aws/build/helper.js";
-import { Config } from "../config.js";
+import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
 /**
  * Bundle the Open Next server.
  */
-export declare function bundleServer(config: Config, openNextOptions: BuildOptions): Promise<void>;
+export declare function bundleServer(buildOpts: BuildOptions): Promise<void>;
 /**
  * Gets the path of the worker.js file generated by the build process
  *
- * @param openNextOptions the open-next build options
+ * @param buildOpts the open-next build options
  * @returns the path of the worker.js file that the build process generates
  */
-export declare function getOutputWorkerPath(openNextOptions: BuildOptions): string;
+export declare function getOutputWorkerPath(buildOpts: BuildOptions): string;

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

@@ -3,27 +3,30 @@ import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { Lang, parse } from "@ast-grep/napi";
+import { getPackagePath } from "@opennextjs/aws/build/helper.js";
 import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
 import { build } from "esbuild";
 import { patchOptionalDependencies } from "./patches/ast/optional-deps.js";
 import * as patches from "./patches/index.js";
+import inlineRequirePagePlugin from "./patches/plugins/require-page.js";
+import setWranglerExternal from "./patches/plugins/wrangler-external.js";
 import { normalizePath, patchCodeWithValidations } from "./utils/index.js";
 /** The dist directory of the Cloudflare adapter package */
 const packageDistDir = path.join(path.dirname(fileURLToPath(import.meta.url)), "../..");
 /**
  * Bundle the Open Next server.
  */
-export async function bundleServer(config, openNextOptions) {
-    patches.copyPackageCliFiles(packageDistDir, config, openNextOptions);
-    const nextConfigStr = fs
-        .readFileSync(path.join(config.paths.output.standaloneApp, "server.js"), "utf8")
-        ?.match(/const nextConfig = ({.+?})\n/)?.[1] ?? {};
+export async function bundleServer(buildOpts) {
+    patches.copyPackageCliFiles(packageDistDir, buildOpts);
+    const { appPath, outputDir, monorepoRoot } = buildOpts;
+    const serverFiles = path.join(outputDir, "server-functions/default", getPackagePath(buildOpts), ".next/required-server-files.json");
+    const nextConfig = JSON.parse(fs.readFileSync(serverFiles, "utf-8")).config;
     console.log(`\x1b[35m⚙️ Bundling the OpenNext server...\n\x1b[0m`);
-    patches.patchWranglerDeps(config);
-    patches.updateWebpackChunksFile(config);
-    const { appBuildOutputPath, appPath, outputDir, monorepoRoot } = openNextOptions;
+    patches.patchWranglerDeps(buildOpts);
+    await patches.updateWebpackChunksFile(buildOpts);
+    patches.patchVercelOgLibrary(buildOpts);
     const outputPath = path.join(outputDir, "server-functions", "default");
-    const packagePath = path.relative(monorepoRoot, appBuildOutputPath);
+    const packagePath = getPackagePath(buildOpts);
     const openNextServer = path.join(outputPath, packagePath, `index.mjs`);
     const openNextServerBundle = path.join(outputPath, packagePath, `handler.mjs`);
     await build({
@@ -33,25 +36,35 @@ export async function bundleServer(config, openNextOptions) {
         format: "esm",
         target: "esnext",
         minify: false,
-        plugins: [createFixRequiresESBuildPlugin(config)],
-        external: ["./middleware/handler.mjs", "caniuse-lite"],
+        plugins: [
+            createFixRequiresESBuildPlugin(buildOpts),
+            inlineRequirePagePlugin(buildOpts),
+            setWranglerExternal(),
+        ],
+        external: [
+            "./middleware/handler.mjs",
+            // Next optional dependencies.
+            "caniuse-lite",
+            "jimp",
+            "probe-image-size",
+        ],
         alias: {
             // 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");
-            "next/dist/compiled/ws": path.join(config.paths.internal.templates, "shims", "empty.js"),
+            "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
             // QUESTION: Why did I encountered this but mhart didn't?
-            "next/dist/compiled/edge-runtime": path.join(config.paths.internal.templates, "shims", "empty.js"),
+            "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": path.join(config.paths.internal.templates, "shims", "env.js"),
+            "@next/env": path.join(buildOpts.outputDir, "cloudflare-templates/shims/env.js"),
         },
         define: {
             // config file used by Next.js, see: https://github.com/vercel/next.js/blob/68a7128/packages/next/src/build/utils.ts#L2137-L2139
-            "process.env.__NEXT_PRIVATE_STANDALONE_CONFIG": JSON.stringify(nextConfigStr),
+            "process.env.__NEXT_PRIVATE_STANDALONE_CONFIG": `${JSON.stringify(nextConfig)}`,
             // Next.js tried to access __dirname so we need to define it
             __dirname: '""',
             // Note: we need the __non_webpack_require__ variable declared as it is used by next-server:
@@ -104,34 +117,28 @@ globalThis.__BUILD_TIMESTAMP_MS__ = ${Date.now()};
 `,
         },
     });
-    await updateWorkerBundledCode(openNextServerBundle, config, openNextOptions);
+    await updateWorkerBundledCode(openNextServerBundle, buildOpts);
     const isMonorepo = monorepoRoot !== appPath;
     if (isMonorepo) {
         fs.writeFileSync(path.join(outputPath, "handler.mjs"), `export * from "./${normalizePath(packagePath)}/handler.mjs";`);
     }
-    console.log(`\x1b[35mWorker saved in \`${getOutputWorkerPath(openNextOptions)}\` 🚀\n\x1b[0m`);
+    console.log(`\x1b[35mWorker saved in \`${getOutputWorkerPath(buildOpts)}\` 🚀\n\x1b[0m`);
 }
 /**
- * This function applies string replacements on the bundled worker code necessary to get it to run in workerd
- *
- * Needless to say all the logic in this function is something we should avoid as much as possible!
- *
- * @param workerOutputFile
- * @param config
+ * This function applies patches required for the code to run on workers.
  */
-async function updateWorkerBundledCode(workerOutputFile, config, openNextOptions) {
+async function updateWorkerBundledCode(workerOutputFile, buildOpts) {
     const code = await readFile(workerOutputFile, "utf8");
     const patchedCode = await patchCodeWithValidations(code, [
         ["require", patches.patchRequire],
-        ["`buildId` function", (code) => patches.patchBuildId(code, config)],
-        ["`loadManifest` function", (code) => patches.patchLoadManifest(code, config)],
-        ["next's require", (code) => patches.inlineNextRequire(code, config)],
-        ["`findDir` function", (code) => patches.patchFindDir(code, config)],
-        ["`evalManifest` function", (code) => patches.inlineEvalManifest(code, config)],
-        ["cacheHandler", (code) => patches.patchCache(code, openNextOptions)],
+        ["`buildId` function", (code) => patches.patchBuildId(code, buildOpts)],
+        ["`loadManifest` function", (code) => patches.patchLoadManifest(code, buildOpts)],
+        ["`findDir` function", (code) => patches.patchFindDir(code, buildOpts)],
+        ["`evalManifest` function", (code) => patches.inlineEvalManifest(code, buildOpts)],
+        ["cacheHandler", (code) => patches.patchCache(code, buildOpts)],
         [
             "'require(this.middlewareManifestPath)'",
-            (code) => patches.inlineMiddlewareManifestRequire(code, config),
+            (code) => patches.inlineMiddlewareManifestRequire(code, buildOpts),
         ],
         ["exception bubbling", patches.patchExceptionBubbling],
         ["`loadInstrumentationModule` function", patches.patchLoadInstrumentationModule],
@@ -153,16 +160,16 @@ async function updateWorkerBundledCode(workerOutputFile, config, openNextOptions
         ],
     ]);
     const bundle = parse(Lang.TypeScript, patchedCode).root();
-    const edits = patchOptionalDependencies(bundle);
+    const { edits } = patchOptionalDependencies(bundle);
     await writeFile(workerOutputFile, bundle.commitEdits(edits));
 }
-function createFixRequiresESBuildPlugin(config) {
+function createFixRequiresESBuildPlugin(options) {
     return {
         name: "replaceRelative",
         setup(build) {
             // Note: we (empty) shim require-hook modules as they generate problematic code that uses requires
             build.onResolve({ filter: getCrossPlatformPathRegex(String.raw `^\./require-hook$`, { escape: false }) }, () => ({
-                path: path.join(config.paths.internal.templates, "shims", "empty.js"),
+                path: path.join(options.outputDir, "cloudflare-templates/shims/empty.js"),
             }));
         },
     };
@@ -170,9 +177,9 @@ function createFixRequiresESBuildPlugin(config) {
 /**
  * Gets the path of the worker.js file generated by the build process
  *
- * @param openNextOptions the open-next build options
+ * @param buildOpts the open-next build options
  * @returns the path of the worker.js file that the build process generates
  */
-export function getOutputWorkerPath(openNextOptions) {
-    return path.join(openNextOptions.outputDir, "worker.js");
+export function getOutputWorkerPath(buildOpts) {
+    return path.join(buildOpts.outputDir, "worker.js");
 }

package/dist/cli/build/open-next/compile-env-files.d.ts

@@ -2,4 +2,4 @@ import { BuildOptions } from "@opennextjs/aws/build/helper.js";
 /**
  * Compiles the values extracted from the project's env files to the output directory for use in the worker.
  */
-export declare function compileEnvFiles(options: BuildOptions): void;
+export declare function compileEnvFiles(buildOpts: BuildOptions): void;

package/dist/cli/build/open-next/compile-env-files.js

@@ -4,6 +4,6 @@ import { extractProjectEnvVars } from "../utils/index.js";
 /**
  * Compiles the values extracted from the project's env files to the output directory for use in the worker.
  */
-export function compileEnvFiles(options) {
-    ["production", "development", "test"].forEach((mode) => fs.appendFileSync(path.join(options.outputDir, `.env.mjs`), `export const ${mode} = ${JSON.stringify(extractProjectEnvVars(mode, options))};\n`));
+export function compileEnvFiles(buildOpts) {
+    ["production", "development", "test"].forEach((mode) => fs.appendFileSync(path.join(buildOpts.outputDir, `.env.mjs`), `export const ${mode} = ${JSON.stringify(extractProjectEnvVars(mode, buildOpts))};\n`));
 }

package/dist/cli/build/patches/ast/optional-deps.d.ts

@@ -1,10 +1,13 @@
 import { type SgNode } from "@ast-grep/napi";
 /**
- * Handle optional dependencies.
+ * Handles optional dependencies.
  *
  * A top level `require(optionalDep)` would throw when the dep is not installed.
  *
  * So we wrap `require(optionalDep)` in a try/catch (if not already present).
  */
-export declare const optionalDepRule = "\nrule:\n  pattern: $$$LHS = require($$$REQ)\n  has:\n    pattern: $MOD\n    kind: string_fragment\n    stopBy: end\n    regex: ^caniuse-lite(/|$)\n  not:\n    inside:\n      kind: try_statement\n      stopBy: end\n\nfix: |-\n  try {\n    $$$LHS = require($$$REQ);\n  } catch {\n    throw new Error('The optional dependency \"$MOD\" is not installed');\n  }\n";
-export declare function patchOptionalDependencies(root: SgNode): import("@ast-grep/napi").Edit[];
+export declare const optionalDepRule = "\nrule:\n  pattern: $$$LHS = require($$$REQ)\n  has:\n    pattern: $MOD\n    kind: string_fragment\n    stopBy: end\n    regex: ^(caniuse-lite|jimp|probe-image-size)(/|$)\n  not:\n    inside:\n      kind: try_statement\n      stopBy: end\n\nfix: |-\n  try {\n    $$$LHS = require($$$REQ);\n  } catch {\n    throw new Error('The optional dependency \"$MOD\" is not installed');\n  }\n";
+export declare function patchOptionalDependencies(root: SgNode): {
+    edits: import("@ast-grep/napi").Edit[];
+    matches: SgNode<import("@ast-grep/napi/types/staticTypes.js").TypesMap, import("@ast-grep/napi/types/staticTypes.js").Kinds<import("@ast-grep/napi/types/staticTypes.js").TypesMap>>[];
+};

package/dist/cli/build/patches/ast/optional-deps.js

@@ -1,6 +1,6 @@
-import { getRuleEdits } from "./util.js";
+import { applyRule } from "./util.js";
 /**
- * Handle optional dependencies.
+ * Handles optional dependencies.
  *
  * A top level `require(optionalDep)` would throw when the dep is not installed.
  *
@@ -13,7 +13,7 @@ rule:
     pattern: $MOD
     kind: string_fragment
     stopBy: end
-    regex: ^caniuse-lite(/|$)
+    regex: ^(caniuse-lite|jimp|probe-image-size)(/|$)
   not:
     inside:
       kind: try_statement
@@ -27,5 +27,5 @@ fix: |-
   }
 `;
 export function patchOptionalDependencies(root) {
-    return getRuleEdits(optionalDepRule, root);
+    return applyRule(optionalDepRule, root);
 }