@opennextjs/cloudflare 1.20.1 → 1.20.3

package/dist/cli/build/build.js

@@ -8,6 +8,7 @@ import { printHeader } from "@opennextjs/aws/build/utils.js";
 import logger from "@opennextjs/aws/logger.js";
 import { ensureNextjsVersionSupported } from "../utils/nextjs-support.js";
 import { bundleServer } from "./bundle-server.js";
+import { bundleNodeMiddleware } from "./open-next/bundle-node-middleware.js";
 import { compileCacheAssetsManifestSqlFile } from "./open-next/compile-cache-assets-manifest.js";
 import { compileEnvFiles } from "./open-next/compile-env-files.js";
 import { compileImages } from "./open-next/compile-images.js";
@@ -62,10 +63,9 @@ export async function build(options, config, projectOpts, wranglerConfig, allowU
         setStandaloneBuildMode(options);
         buildNextjsApp(options);
     }
-    // Make sure no Node.js middleware is used
-    if (useNodeMiddleware(options)) {
-        logger.error("Node.js middleware is not currently supported. Consider switching to Edge Middleware.");
-        process.exit(1);
+    const hasNodeMiddleware = useNodeMiddleware(options);
+    if (hasNodeMiddleware) {
+        logger.warn("Node.js middleware support is experimental in cloudflare, and not officially maintained by OpenNext maintainers. Use at your own risk.");
     }
     // Generate deployable bundle
     printHeader("Generating bundle");
@@ -77,6 +77,9 @@ export async function build(options, config, projectOpts, wranglerConfig, allowU
     await compileSkewProtection(options, config);
     // Compile middleware
     await createMiddleware(options, { forceOnlyBuildOnce: true });
+    if (hasNodeMiddleware) {
+        await bundleNodeMiddleware(options);
+    }
     createStaticAssets(options, { useBasePath: true });
     if (config.dangerous?.disableIncrementalCache !== true) {
         const { useTagCache, metaFiles } = createCacheAssets(options);

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

@@ -52,7 +52,7 @@ export async function bundleServer(buildOpts, projectOpts) {
     const nextConfig = JSON.parse(fs.readFileSync(serverFiles, "utf-8")).config;
     const useTurbopack = buildHelper.getBundlerRuntime(buildOpts) === "turbopack";
     console.log(`\x1b[35m⚙️ Bundling the OpenNext server...\n\x1b[0m`);
-    await patchWebpackRuntime(buildOpts);
+    await patchWebpackRuntime(path.join(dotNextPath, "server"));
     const useOg = patchVercelOgLibrary(buildOpts);
     const outputPath = path.join(outputDir, "server-functions", "default");
     const packagePath = getPackagePath(buildOpts);

package/dist/cli/build/open-next/bundle-node-middleware.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Bundles the Node.js middleware (`proxy.ts` / `middleware.ts` with the `nodejs` runtime)
+ * into a Workers compatible `middleware/handler.mjs`.
+ *
+ * NOTE: Running Next.js Node.js middleware on workerd is experimental and is not supported
+ * by the OpenNext maintainers. It re-bundles the middleware compiled by Next.js, which is an
+ * internal output that can change between Next.js versions.
+ *
+ * `@opennextjs/aws` bundles the external middleware for a Node.js server:
+ * the OpenNext config is read from the filesystem at runtime and the middleware compiled
+ * by Next.js is loaded with `await import("./.next/server/middleware.js")`.
+ *
+ * workerd can not access the filesystem nor load modules at runtime, so the handler
+ * built by `@opennextjs/aws` is replaced with a fully self-contained bundle:
+ *
+ * - the config manifests are inlined by `openNextEdgePlugins` (as for the edge middleware)
+ * - the middleware compiled by Next.js is statically bundled from the traced files that
+ *   `@opennextjs/aws` copies to `middleware/<package path>/.next/server/middleware.js`
+ */
+import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
+import { type Plugin } from "esbuild";
+/**
+ * Resolves the middleware compiled by Next.js to the copy created by `copyTracedFiles`.
+ *
+ * `@opennextjs/aws`'s `nodeMiddlewareHandler` loads the middleware with a dynamic
+ * `await import("./.next/server/middleware.js")` that nothing on the aws side resolves (it relies
+ * on the adapter bundling it), so this resolves that specifier to the traced copy.
+ */
+export declare function setCompiledMiddlewarePlugin(compiledMiddlewarePath: string): Plugin;
+/**
+ * Makes the Node.js builtins used by the bundled code (i.e. `require("crypto")` or
+ * `import from "node:crypto"`) resolve to the modules workerd provides via `nodejs_compat`.
+ *
+ * `require` calls are converted into a virtual CommonJS module re-exporting the builtin.
+ * The virtual module has to stay CommonJS - esbuild classifies it as such because it assigns to
+ * `module.exports` and uses no `export` keyword - so that `require("crypto")` receives the module
+ * workerd provides rather than an esbuild `__toCommonJS` wrapper built from its named exports,
+ * which would drop whatever the named exports do not expose and add a synthetic `__esModule`.
+ *
+ * The conversion is kept in sync with `handleRequireCallsToNodeJSBuiltins` in wrangler's
+ * `hybrid-nodejs-compat` esbuild plugin, which is the source of truth:
+ * https://github.com/cloudflare/workers-sdk/blob/c457bfc6b5a575586354f5b0ad7a1100eff915fe/packages/wrangler/src/deployment-bundle/esbuild-plugins/hybrid-nodejs-compat.ts#L102-L133
+ *
+ * It differs on a single intentional point: the builtin is imported as a namespace and
+ * `mod.default ?? mod` is used rather than a default import, so that a builtin without a `default`
+ * export can not fail to link in workerd. wrangler applies the same fallback to its unenv aliases
+ * in `handleUnenvAliasedPackages`.
+ */
+export declare function nodeBuiltinsPlugin(): Plugin;
+export declare function bundleNodeMiddleware(options: BuildOptions): Promise<void>;

package/dist/cli/build/open-next/bundle-node-middleware.js

@@ -0,0 +1,274 @@
+/**
+ * Bundles the Node.js middleware (`proxy.ts` / `middleware.ts` with the `nodejs` runtime)
+ * into a Workers compatible `middleware/handler.mjs`.
+ *
+ * NOTE: Running Next.js Node.js middleware on workerd is experimental and is not supported
+ * by the OpenNext maintainers. It re-bundles the middleware compiled by Next.js, which is an
+ * internal output that can change between Next.js versions.
+ *
+ * `@opennextjs/aws` bundles the external middleware for a Node.js server:
+ * the OpenNext config is read from the filesystem at runtime and the middleware compiled
+ * by Next.js is loaded with `await import("./.next/server/middleware.js")`.
+ *
+ * workerd can not access the filesystem nor load modules at runtime, so the handler
+ * built by `@opennextjs/aws` is replaced with a fully self-contained bundle:
+ *
+ * - the config manifests are inlined by `openNextEdgePlugins` (as for the edge middleware)
+ * - the middleware compiled by Next.js is statically bundled from the traced files that
+ *   `@opennextjs/aws` copies to `middleware/<package path>/.next/server/middleware.js`
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { builtinModules, isBuiltin } from "node:module";
+import path from "node:path";
+import { getBundlerRuntime, getPackagePath } from "@opennextjs/aws/build/helper.js";
+import logger from "@opennextjs/aws/logger.js";
+import { ContentUpdater } from "@opennextjs/aws/plugins/content-updater.js";
+import { openNextEdgePlugins } from "@opennextjs/aws/plugins/edge.js";
+import { openNextExternalMiddlewarePlugin } from "@opennextjs/aws/plugins/externalMiddleware.js";
+import { openNextReplacementPlugin } from "@opennextjs/aws/plugins/replacement.js";
+import { openNextResolvePlugin } from "@opennextjs/aws/plugins/resolve.js";
+import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
+import { build } from "esbuild";
+import { glob } from "glob";
+import { normalizePath } from "../../utils/normalize-path.js";
+import { patchWebpackRuntime } from "../patches/ast/webpack-runtime.js";
+import { patchInstrumentation } from "../patches/plugins/instrumentation.js";
+import { patchTurbopackRuntimeCode, patchTurbopackWasmChunkCode } from "../patches/plugins/turbopack.js";
+import { setWranglerExternal } from "../patches/plugins/wrangler-external.js";
+/**
+ * Inlines the chunks of the middleware compiled by Next.js.
+ *
+ * Both the webpack and the Turbopack runtimes resolve the chunks they need at runtime,
+ * which workerd does not support. The same patches as for the server are used to inline them.
+ *
+ * @param options Build options.
+ * @param dotNextServerDir The `.next/server` directory of the middleware output.
+ */
+async function inlineMiddlewareChunks(options, dotNextServerDir) {
+    if (getBundlerRuntime(options) !== "turbopack") {
+        await patchWebpackRuntime(dotNextServerDir);
+        return;
+    }
+    const runtimePath = path.join(dotNextServerDir, "chunks/[turbopack]_runtime.js");
+    if (!existsSync(runtimePath)) {
+        throw new Error(`Turbopack runtime not found at ${runtimePath}`);
+    }
+    // The Turbopack runtime resolves the chunks relative to the `.next` directory.
+    // `.wasm` chunks are needed too: they are inlined as static imports by `loadWasmChunk`.
+    const tracedFiles = await glob(path.join(dotNextServerDir, "**/*.{js,wasm}"), {
+        windowsPathsNoEscape: true,
+    });
+    writeFileSync(runtimePath, patchTurbopackRuntimeCode({
+        code: readFileSync(runtimePath, "utf-8"),
+        filePath: normalizePath(runtimePath),
+        tracedFiles,
+    }));
+    // Since Next.js 16.3 the wasm helpers are emitted in the chunks rather than in the runtime.
+    for (const chunkPath of tracedFiles) {
+        if (!chunkPath.endsWith(".js") || normalizePath(chunkPath) === normalizePath(runtimePath)) {
+            continue;
+        }
+        const code = readFileSync(chunkPath, "utf-8");
+        const patched = patchTurbopackWasmChunkCode({ code, tracedFiles });
+        if (patched !== code) {
+            writeFileSync(chunkPath, patched);
+        }
+    }
+}
+/**
+ * Resolves the middleware compiled by Next.js to the copy created by `copyTracedFiles`.
+ *
+ * `@opennextjs/aws`'s `nodeMiddlewareHandler` loads the middleware with a dynamic
+ * `await import("./.next/server/middleware.js")` that nothing on the aws side resolves (it relies
+ * on the adapter bundling it), so this resolves that specifier to the traced copy.
+ */
+export function setCompiledMiddlewarePlugin(compiledMiddlewarePath) {
+    return {
+        name: "compiled-middleware",
+        setup(build) {
+            build.onResolve({ filter: getCrossPlatformPathRegex("./.next/server/middleware.js") }, () => ({
+                path: compiledMiddlewarePath,
+            }));
+        },
+    };
+}
+/**
+ * Makes the Node.js builtins used by the bundled code (i.e. `require("crypto")` or
+ * `import from "node:crypto"`) resolve to the modules workerd provides via `nodejs_compat`.
+ *
+ * `require` calls are converted into a virtual CommonJS module re-exporting the builtin.
+ * The virtual module has to stay CommonJS - esbuild classifies it as such because it assigns to
+ * `module.exports` and uses no `export` keyword - so that `require("crypto")` receives the module
+ * workerd provides rather than an esbuild `__toCommonJS` wrapper built from its named exports,
+ * which would drop whatever the named exports do not expose and add a synthetic `__esModule`.
+ *
+ * The conversion is kept in sync with `handleRequireCallsToNodeJSBuiltins` in wrangler's
+ * `hybrid-nodejs-compat` esbuild plugin, which is the source of truth:
+ * https://github.com/cloudflare/workers-sdk/blob/c457bfc6b5a575586354f5b0ad7a1100eff915fe/packages/wrangler/src/deployment-bundle/esbuild-plugins/hybrid-nodejs-compat.ts#L102-L133
+ *
+ * It differs on a single intentional point: the builtin is imported as a namespace and
+ * `mod.default ?? mod` is used rather than a default import, so that a builtin without a `default`
+ * export can not fail to link in workerd. wrangler applies the same fallback to its unenv aliases
+ * in `handleUnenvAliasedPackages`.
+ */
+export function nodeBuiltinsPlugin() {
+    const namespace = "node-builtins";
+    // Match only Node.js builtins so esbuild does not call back on every import:
+    // the `node:` prefixed form and the bare names (`crypto`, `fs`, ...).
+    const builtinsFilter = new RegExp(`^(node:|(${builtinModules.join("|")})$)`);
+    return {
+        name: namespace,
+        setup(build) {
+            build.onResolve({ filter: builtinsFilter }, ({ path: specifier, kind }) => {
+                if (!isBuiltin(specifier)) {
+                    return undefined;
+                }
+                const prefixed = specifier.startsWith("node:") ? specifier : `node:${specifier}`;
+                return kind === "require-call" ? { path: prefixed, namespace } : { path: prefixed, external: true };
+            });
+            build.onLoad({ filter: /^node:/, namespace }, ({ path: builtin }) => ({
+                contents: `
+					import * as mod from "${builtin}";
+					module.exports = mod.default ?? mod;
+				`,
+                loader: "js",
+            }));
+        },
+    };
+}
+export async function bundleNodeMiddleware(options) {
+    const { config, outputDir } = options;
+    const middlewareDir = path.join(outputDir, "middleware");
+    const dotNextServerDir = path.join(middlewareDir, getPackagePath(options), ".next/server");
+    const compiledMiddleware = path.join(dotNextServerDir, "middleware.js");
+    if (!existsSync(compiledMiddleware)) {
+        throw new Error(`Compiled Node.js middleware not found at ${compiledMiddleware}`);
+    }
+    // The bundler runtime resolves the chunks of the middleware at runtime, which workerd does
+    // not support. Inline the chunks so that they are statically bundled.
+    await inlineMiddlewareChunks(options, dotNextServerDir);
+    logger.info("Bundling Node.js middleware...");
+    const middlewareConfig = config.middleware?.external ? config.middleware : undefined;
+    const overrides = {
+        ...middlewareConfig?.override,
+        originResolver: middlewareConfig?.originResolver,
+    };
+    function override(target) {
+        // String and lazy loaded overrides are supported, see `buildEdgeBundle`
+        return typeof overrides[target] === "string" || typeof overrides[target] === "function"
+            ? overrides[target]
+            : undefined;
+    }
+    const includeCache = config.dangerous?.enableCacheInterception;
+    // `next/dist/server/lib/trace/tracer.js` requires `@opentelemetry/api`, an optional
+    // dependency that most apps do not install. On the edge runtime Next.js does not fall
+    // back to its compiled copy when the require throws, so alias to that copy - but only
+    // when the app has not installed the real package, otherwise the real one is used.
+    const hasOpentelemetry = existsSync(path.join(options.appBuildOutputPath, "node_modules", "@opentelemetry", "api"));
+    const updater = new ContentUpdater(options);
+    await build({
+        entryPoints: [path.join(options.openNextDistDir, "adapters", "middleware.js")],
+        outfile: path.join(middlewareDir, "handler.mjs"),
+        allowOverwrite: true,
+        bundle: true,
+        format: "esm",
+        target: "es2022",
+        platform: "neutral",
+        minify: options.minify,
+        sourcemap: options.debug ? "inline" : false,
+        sourcesContent: false,
+        treeShaking: true,
+        conditions: ["module"],
+        mainFields: ["module", "main"],
+        external: ["node:*", "./open-next.config.mjs"],
+        define: {
+            // The base of the middleware compiled by Next.js is runtime agnostic. "edge" selects its
+            // Web API code paths (which workerd supports) over the Node.js server paths (which it does
+            // not): it also skips `setup-node-env.external.js`, which patches read-only workerd globals.
+            // Node.js builtins used by the middleware are still provided by workerd via `nodejs_compat`.
+            "process.env.NEXT_RUNTIME": '"edge"',
+            "process.env.NODE_ENV": '"production"',
+        },
+        alias: {
+            // See `hasOpentelemetry` above.
+            ...(hasOpentelemetry ? {} : { "@opentelemetry/api": "next/dist/compiled/@opentelemetry/api" }),
+        },
+        plugins: [
+            openNextResolvePlugin({
+                overrides: {
+                    wrapper: override("wrapper") ?? "cloudflare-edge",
+                    converter: override("converter") ?? "edge",
+                    ...(includeCache
+                        ? {
+                            tagCache: override("tagCache"),
+                            incrementalCache: override("incrementalCache"),
+                            queue: override("queue"),
+                        }
+                        : {}),
+                    originResolver: override("originResolver") ?? "pattern-env",
+                    proxyExternalRequest: override("proxyExternalRequest") ?? "fetch",
+                },
+                fnName: "middleware",
+            }),
+            openNextReplacementPlugin({
+                name: "externalMiddlewareOverrides",
+                target: getCrossPlatformPathRegex("adapters/middleware.js"),
+                deletes: includeCache ? [] : ["includeCacheInMiddleware"],
+            }),
+            // Handle the middleware with the OpenNext Node.js middleware handler
+            openNextExternalMiddlewarePlugin(path.join(options.openNextDistDir, "core", "nodeMiddlewareHandler.js")),
+            setCompiledMiddlewarePlugin(compiledMiddleware),
+            // `.wasm` and `.bin` files are bundled by wrangler, not by this build
+            setWranglerExternal(),
+            // Must be registered before `openNextEdgePlugins` to handle `require("node:*")` calls
+            nodeBuiltinsPlugin(),
+            // Inline the config manifests
+            openNextEdgePlugins({
+                nextDir: path.join(options.appBuildOutputPath, ".next"),
+                isInCloudflare: true,
+            }),
+            // Next.js 16.3 registers the instrumentation hook from the middleware itself when the
+            // middleware does not run on the edge runtime, by dynamically requiring
+            // `.next/server/instrumentation.js` - which workerd does not support.
+            //
+            // The guard Next.js uses (`process.env.NEXT_RUNTIME !== "edge"`) is inlined to `"nodejs"`
+            // when Next.js compiles the middleware, so the `define` above can not eliminate the branch.
+            // The loader is stubbed out instead, which matches what the edge runtime does here: it has
+            // no instrumentation entry to register, and the server function - which shares the isolate -
+            // already registers the hook.
+            // See https://github.com/opennextjs/opennextjs-cloudflare/issues/1362
+            patchInstrumentation(updater, options, { loadInstrumentation: false }),
+            // Apply updater updates, must be the last plugin
+            updater.plugin,
+        ],
+        banner: {
+            js: `
+import { Buffer } from "node:buffer";
+globalThis.Buffer = Buffer;
+
+// Next.js' compiled middleware references \`AsyncLocalStorage\` as a global. workerd only
+// exposes it via \`node:async_hooks\` (not as a global, even with \`nodejs_compat\`), so it is
+// assigned here - as \`@opennextjs/aws\`'s edge middleware bundler does.
+import { AsyncLocalStorage } from "node:async_hooks";
+globalThis.AsyncLocalStorage = AsyncLocalStorage;
+
+// Next.js sets \`__import_unsupported\` on \`globalThis\` with \`configurable: false\`.
+// When the middleware and the server share a Worker, the second call would throw,
+// so it is skipped when the property is already set. Otherwise it runs as usual.
+// See https://github.com/vercel/next.js/blob/5b7833e3/packages/next/src/server/web/globals.ts#L94-L98
+const defaultDefineProperty = Object.defineProperty;
+Object.defineProperty = function (o, p, a) {
+	if (p === "__import_unsupported" && Boolean(globalThis.__import_unsupported)) {
+		// \`Object.defineProperty\` returns the object it was passed.
+		return o;
+	}
+	return defaultDefineProperty(o, p, a);
+};
+
+globalThis.openNextDebug = ${options.debug};
+globalThis.openNextVersion = "${options.openNextVersion}";
+globalThis.nextVersion = "${options.nextVersion}";
+`,
+        },
+    });
+}

package/dist/cli/build/patches/ast/webpack-runtime.d.ts

@@ -19,11 +19,10 @@
  * For a single chunk:
  *     require("./chunks/CHUNK_ID.js");
  */
-import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
 export declare function buildMultipleChunksRule(chunks: number[]): string;
 export declare const singleChunkRule = "\nrule:\n  pattern: ($CHUNK_ID, $_PROMISES) => { $$$ }\n  inside: {pattern: $_.$_.require = $$$_, stopBy: end}\n  all:\n    - has: {pattern: $INSTALL(require(\"./chunks/\" + $$$)), stopBy: end}\n    - has: {pattern: $SELF_ID == $CHUNK_ID, stopBy: end}\n    - has: {pattern: \"$INSTALLED_CHUNK[$CHUNK_ID] = 1\", stopBy: end}\nfix: |\n  ($CHUNK_ID, _) => {\n    if (!$INSTALLED_CHUNK[$CHUNK_ID]) {\n      try {\n        $INSTALL(require(\"./chunks/$SELF_ID.js\"));\n      } catch {}\n    }\n  }\n";
 /**
  * Fixes the webpack-runtime.js and webpack-api-runtime.js files by inlining
  * the webpack dynamic requires.
  */
-export declare function patchWebpackRuntime(buildOpts: BuildOptions): Promise<void>;
+export declare function patchWebpackRuntime(dotNextServerDir: string): Promise<void>;

package/dist/cli/build/patches/ast/webpack-runtime.js

@@ -21,7 +21,6 @@
  */
 import { existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { getPackagePath } from "@opennextjs/aws/build/helper.js";
 import { patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
 // Inline the code when there are multiple chunks
 export function buildMultipleChunksRule(chunks) {
@@ -68,15 +67,16 @@ fix: |
  * Fixes the webpack-runtime.js and webpack-api-runtime.js files by inlining
  * the webpack dynamic requires.
  */
-export async function patchWebpackRuntime(buildOpts) {
-    const { outputDir } = buildOpts;
-    const dotNextServerDir = join(outputDir, "server-functions/default", getPackagePath(buildOpts), ".next/server");
+export async function patchWebpackRuntime(dotNextServerDir) {
     // Look for all the chunks.
-    const chunks = readdirSync(join(dotNextServerDir, "chunks"))
-        .filter((chunk) => /^\d+\.js$/.test(chunk))
-        .map((chunk) => {
-        return Number(chunk.replace(/\.js$/, ""));
-    });
+    const chunksDir = join(dotNextServerDir, "chunks");
+    const chunks = existsSync(chunksDir)
+        ? readdirSync(chunksDir)
+            .filter((chunk) => /^\d+\.js$/.test(chunk))
+            .map((chunk) => {
+            return Number(chunk.replace(/\.js$/, ""));
+        })
+        : [];
     patchFile(join(dotNextServerDir, "webpack-runtime.js"), chunks);
     patchFile(join(dotNextServerDir, "webpack-api-runtime.js"), chunks);
 }

package/dist/cli/build/patches/plugins/instrumentation.d.ts

@@ -1,6 +1,21 @@
 import { type BuildOptions } from "@opennextjs/aws/build/helper.js";
 import type { ContentUpdater, Plugin } from "@opennextjs/aws/plugins/content-updater.js";
-export declare function patchInstrumentation(updater: ContentUpdater, buildOpts: BuildOptions): Plugin;
+/**
+ * Replaces the dynamic loading of the instrumentation hook, which workerd does not support.
+ *
+ * Next.js loads `.next/server/instrumentation.js` with a `require()` call built from a path
+ * computed at runtime. The loaders are rewritten to either statically `require()` the file that
+ * the Next.js build emitted, or to resolve to `null` when the app has no instrumentation hook.
+ *
+ * @param updater The content updater applying the patches.
+ * @param buildOpts The open-next build options.
+ * @param options.loadInstrumentation When `false`, the loaders always resolve to `null` so that the
+ * instrumentation hook is never registered by this bundle. Defaults to `true`.
+ * @returns An esbuild plugin.
+ */
+export declare function patchInstrumentation(updater: ContentUpdater, buildOpts: BuildOptions, { loadInstrumentation }?: {
+    loadInstrumentation?: boolean;
+}): Plugin;
 export declare function getNext154Rule(builtInstrumentationPath: string | null): string;
 export declare function getNext15Rule(builtInstrumentationPath: string | null): string;
 export declare function getNext14Rule(builtInstrumentationPath: string | null): string;

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

@@ -4,8 +4,21 @@ 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/normalize-path.js";
-export function patchInstrumentation(updater, buildOpts) {
-    const builtInstrumentationPath = getBuiltInstrumentationPath(buildOpts);
+/**
+ * Replaces the dynamic loading of the instrumentation hook, which workerd does not support.
+ *
+ * Next.js loads `.next/server/instrumentation.js` with a `require()` call built from a path
+ * computed at runtime. The loaders are rewritten to either statically `require()` the file that
+ * the Next.js build emitted, or to resolve to `null` when the app has no instrumentation hook.
+ *
+ * @param updater The content updater applying the patches.
+ * @param buildOpts The open-next build options.
+ * @param options.loadInstrumentation When `false`, the loaders always resolve to `null` so that the
+ * instrumentation hook is never registered by this bundle. Defaults to `true`.
+ * @returns An esbuild plugin.
+ */
+export function patchInstrumentation(updater, buildOpts, { loadInstrumentation = true } = {}) {
+    const builtInstrumentationPath = loadInstrumentation ? getBuiltInstrumentationPath(buildOpts) : null;
     updater.updateContent("patch-instrumentation-next15-4", [
         {
             filter: getCrossPlatformPathRegex(String.raw `/server/lib/router-utils/instrumentation-globals.external\.js$`, {

package/dist/cli/build/patches/plugins/turbopack.d.ts

@@ -15,6 +15,63 @@ export declare const replaceLoadWebAssemblyModuleRule = "\nrule:\n  kind: functi
  * the synchronous `WebAssembly.instantiate` to produce the instance's exports.
  */
 export declare const replaceLoadWebAssemblyRule = "\nrule:\n  kind: function_declaration\n  has:\n    field: name\n    regex: \"^loadWebAssembly$\"\nfix: |-\n  async function loadWebAssembly(chunkPath, _edgeModule, imports) {\n    const mod = await loadWasmChunk(chunkPath);\n    const { exports } = await WebAssembly.instantiate(mod, imports);\n    return exports;\n  }\n";
+/**
+ * Replace the `compileModule` helper that Next.js 16.3 emits in the chunks.
+ *
+ * Next.js 16.3 moved the wasm loading out of `[turbopack]_runtime.js`: it is now emitted on
+ * demand in the chunks as `[turbopack-wasm]/node/loadWasm.ts`, which reads the `.wasm` file from
+ * the filesystem and compiles it with `WebAssembly.compileStreaming`. Neither is supported by
+ * workerd so the helper is rewritten to use the generated `loadWasmChunk`.
+ *
+ * The emitted code is minified, so the rule matches on the shape of the helper rather than on its
+ * name: an async function taking the chunk path as its only parameter and returning the result of
+ * `WebAssembly.compileStreaming(...)`.
+ *
+ * See https://github.com/opennextjs/opennextjs-cloudflare/issues/1342
+ */
+export declare const replaceCompileModuleRule = "\nrule:\n  all:\n    - pattern:\n        context: async function $NAME($PATH) { $$$BODY }\n        selector: function_declaration\n    - has:\n        field: body\n        has:\n          kind: return_statement\n          has:\n            pattern: WebAssembly.compileStreaming($$$)\n            stopBy: end\nfix: |-\n  async function $NAME($PATH) {\n    return loadWasmChunk($PATH);\n  }\n";
+/**
+ * Replace the `instantiate` helper that Next.js 16.3 emits in the chunks.
+ *
+ * The counterpart of {@link replaceCompileModuleRule} for the helper instantiating the module:
+ * `WebAssembly.instantiateStreaming` is not supported by workerd either, so the chunk is loaded
+ * with the generated `loadWasmChunk` and instantiated with the synchronous `WebAssembly.instantiate`.
+ *
+ * The rule matches an async function taking the chunk path and the imports as parameters, and
+ * declaring a variable from the result of `WebAssembly.instantiateStreaming(...)`.
+ */
+export declare const replaceInstantiateModuleRule = "\nrule:\n  all:\n    - pattern:\n        context: async function $NAME($PATH, $IMPORTS) { $$$BODY }\n        selector: function_declaration\n    - has:\n        field: body\n        has:\n          kind: lexical_declaration\n          has:\n            pattern: WebAssembly.instantiateStreaming($$$)\n            stopBy: end\nfix: |-\n  async function $NAME($PATH, $IMPORTS) {\n    const module = await loadWasmChunk($PATH);\n    const { exports } = await WebAssembly.instantiate(module, $IMPORTS);\n    return exports;\n  }\n";
+/**
+ * Inline the dynamic chunk requires of the Turbopack runtime.
+ *
+ * The runtime resolves the chunks it needs at runtime, which workerd does not support.
+ * The chunks are inlined so that they are statically bundled.
+ *
+ * @param code The code of the Turbopack runtime.
+ * @param filePath Path to the Turbopack runtime, in the OpenNext output.
+ * @param tracedFiles The files traced by Next.js, copied next to the runtime.
+ * @returns The patched code.
+ */
+export declare function patchTurbopackRuntimeCode({ code, filePath, tracedFiles, }: {
+    code: string;
+    filePath: string;
+    tracedFiles: string[];
+}): string;
+/**
+ * Replace the wasm helpers that Next.js 16.3 emits in the Turbopack chunks.
+ *
+ * Until Next.js 16.2 the wasm loaders lived in `[turbopack]_runtime.js` and were patched by
+ * {@link patchTurbopackRuntimeCode}. Next.js 16.3 emits them on demand in the chunks instead, so
+ * the chunks need to be patched too.
+ *
+ * @param code The code of the Turbopack chunk.
+ * @param tracedFiles The files traced by Next.js.
+ * @returns The patched code, or `code` unchanged when the chunk has no wasm helper.
+ */
+export declare function patchTurbopackWasmChunkCode({ code, tracedFiles, }: {
+    code: string;
+    tracedFiles: string[];
+}): string;
 export declare const patchTurbopackRuntime: CodePatcher;
 /**
  * Generate a `loadWasmChunk` function that maps a `.next`-relative chunk path to a

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

@@ -1,7 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
-import { patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
+import { applyRule, parseCode, patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
 import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
+import { normalizePath } from "../../../utils/normalize-path.js";
 const inlineChunksRule = `
 rule:
   kind: call_expression
@@ -47,6 +48,68 @@ fix: |-
     return exports;
   }
 `;
+/**
+ * Replace the `compileModule` helper that Next.js 16.3 emits in the chunks.
+ *
+ * Next.js 16.3 moved the wasm loading out of `[turbopack]_runtime.js`: it is now emitted on
+ * demand in the chunks as `[turbopack-wasm]/node/loadWasm.ts`, which reads the `.wasm` file from
+ * the filesystem and compiles it with `WebAssembly.compileStreaming`. Neither is supported by
+ * workerd so the helper is rewritten to use the generated `loadWasmChunk`.
+ *
+ * The emitted code is minified, so the rule matches on the shape of the helper rather than on its
+ * name: an async function taking the chunk path as its only parameter and returning the result of
+ * `WebAssembly.compileStreaming(...)`.
+ *
+ * See https://github.com/opennextjs/opennextjs-cloudflare/issues/1342
+ */
+export const replaceCompileModuleRule = `
+rule:
+  all:
+    - pattern:
+        context: async function $NAME($PATH) { $$$BODY }
+        selector: function_declaration
+    - has:
+        field: body
+        has:
+          kind: return_statement
+          has:
+            pattern: WebAssembly.compileStreaming($$$)
+            stopBy: end
+fix: |-
+  async function $NAME($PATH) {
+    return loadWasmChunk($PATH);
+  }
+`;
+/**
+ * Replace the `instantiate` helper that Next.js 16.3 emits in the chunks.
+ *
+ * The counterpart of {@link replaceCompileModuleRule} for the helper instantiating the module:
+ * `WebAssembly.instantiateStreaming` is not supported by workerd either, so the chunk is loaded
+ * with the generated `loadWasmChunk` and instantiated with the synchronous `WebAssembly.instantiate`.
+ *
+ * The rule matches an async function taking the chunk path and the imports as parameters, and
+ * declaring a variable from the result of `WebAssembly.instantiateStreaming(...)`.
+ */
+export const replaceInstantiateModuleRule = `
+rule:
+  all:
+    - pattern:
+        context: async function $NAME($PATH, $IMPORTS) { $$$BODY }
+        selector: function_declaration
+    - has:
+        field: body
+        has:
+          kind: lexical_declaration
+          has:
+            pattern: WebAssembly.instantiateStreaming($$$)
+            stopBy: end
+fix: |-
+  async function $NAME($PATH, $IMPORTS) {
+    const module = await loadWasmChunk($PATH);
+    const { exports } = await WebAssembly.instantiate(module, $IMPORTS);
+    return exports;
+  }
+`;
 /**
  * Discover Turbopack external module mappings by reading symlinks in .next/node_modules/.
  *
@@ -220,6 +283,52 @@ function discoverExternalSubpaths(mappings, tracedFiles) {
     }
     return subpaths;
 }
+/**
+ * Inline the dynamic chunk requires of the Turbopack runtime.
+ *
+ * The runtime resolves the chunks it needs at runtime, which workerd does not support.
+ * The chunks are inlined so that they are statically bundled.
+ *
+ * @param code The code of the Turbopack runtime.
+ * @param filePath Path to the Turbopack runtime, in the OpenNext output.
+ * @param tracedFiles The files traced by Next.js, copied next to the runtime.
+ * @returns The patched code.
+ */
+export function patchTurbopackRuntimeCode({ code, filePath, tracedFiles, }) {
+    tracedFiles = tracedFiles.map(normalizePath);
+    filePath = normalizePath(filePath);
+    const mappings = discoverExternalModuleMappings(filePath);
+    const externalImportRule = buildExternalImportRule(mappings, tracedFiles, code);
+    let patched = patchCode(code, externalImportRule);
+    patched = patchCode(patched, inlineChunksRule);
+    patched = patchCode(patched, replaceLoadWebAssemblyModuleRule);
+    patched = patchCode(patched, replaceLoadWebAssemblyRule);
+    return `${patched}
+${inlineChunksFn(tracedFiles)}\n${loadWasmChunkFn(tracedFiles)}`;
+}
+/**
+ * Replace the wasm helpers that Next.js 16.3 emits in the Turbopack chunks.
+ *
+ * Until Next.js 16.2 the wasm loaders lived in `[turbopack]_runtime.js` and were patched by
+ * {@link patchTurbopackRuntimeCode}. Next.js 16.3 emits them on demand in the chunks instead, so
+ * the chunks need to be patched too.
+ *
+ * @param code The code of the Turbopack chunk.
+ * @param tracedFiles The files traced by Next.js.
+ * @returns The patched code, or `code` unchanged when the chunk has no wasm helper.
+ */
+export function patchTurbopackWasmChunkCode({ code, tracedFiles, }) {
+    const root = parseCode(code);
+    // The 2 rules can not match the same function: they differ by the arity of the helper.
+    const edits = [
+        ...applyRule(replaceCompileModuleRule, root).edits,
+        ...applyRule(replaceInstantiateModuleRule, root).edits,
+    ];
+    if (edits.length === 0) {
+        return code;
+    }
+    return `${root.commitEdits(edits)}\n${loadWasmChunkFn(tracedFiles.map(normalizePath))}`;
+}
 export const patchTurbopackRuntime = {
     name: "inline-turbopack-chunks",
     patches: [
@@ -229,16 +338,18 @@ export const patchTurbopackRuntime = {
                 escape: false,
             }),
             contentFilter: /loadRuntimeChunkPath/,
-            patchCode: async ({ code, tracedFiles, filePath }) => {
-                const mappings = discoverExternalModuleMappings(filePath);
-                const externalImportRule = buildExternalImportRule(mappings, tracedFiles, code);
-                let patched = patchCode(code, externalImportRule);
-                patched = patchCode(patched, inlineChunksRule);
-                patched = patchCode(patched, replaceLoadWebAssemblyModuleRule);
-                patched = patchCode(patched, replaceLoadWebAssemblyRule);
-                return `${patched}
-${inlineChunksFn(tracedFiles)}\n${loadWasmChunkFn(tracedFiles)}`;
-            },
+            patchCode: async ({ code, tracedFiles, filePath }) => patchTurbopackRuntimeCode({ code, filePath, tracedFiles }),
+        },
+        {
+            // Next.js 16.3.0 moved the wasm loaders out of the Turbopack runtime and started
+            // emitting them on demand in the chunks that need them. Earlier versions are handled
+            // by the runtime patch above.
+            versions: ">=16.3.0",
+            pathFilter: getCrossPlatformPathRegex(String.raw `/\.next/server/chunks/.+\.js$`, {
+                escape: false,
+            }),
+            contentFilter: /WebAssembly\.(compileStreaming|instantiateStreaming)/,
+            patchCode: async ({ code, tracedFiles }) => patchTurbopackWasmChunkCode({ code, tracedFiles }),
         },
     ],
 };

package/dist/cli/utils/create-wrangler-config.js

@@ -34,7 +34,7 @@ export function findWranglerConfig(appDir) {
  * @returns An object containing a `cachingEnabled` which indicates whether caching has been set up during the wrangler
  *          config file creation or not
  */
-export async function createWranglerConfigFile(projectDir, defaultCompatDate = "2026-04-15") {
+export async function createWranglerConfigFile(projectDir, defaultCompatDate = "2026-08-01") {
     const workerName = getWorkerName(projectDir);
     const compatibilityDate = (await getLatestCompatDate()) ?? defaultCompatDate;
     const wranglerConfigStr = readFileSync(join(getPackageTemplatesDirPath(), "wrangler.jsonc"), "utf8")

package/dist/cli/utils/normalize-path.js

@@ -1,4 +1,3 @@
-import { posix, sep } from "node:path";
 export function normalizePath(path) {
-    return path.replaceAll(sep, posix.sep);
+    return path.replaceAll("\\", "/");
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "1.20.1",
+  "version": "1.20.3",
   "type": "module",
   "bin": {
     "opennextjs-cloudflare": "dist/cli/index.js"
@@ -44,7 +44,7 @@
   "dependencies": {
     "@ast-grep/napi": "^0.40.5",
     "@dotenvx/dotenvx": "1.31.0",
-    "@opennextjs/aws": "4.0.2",
+    "@opennextjs/aws": "4.1.1",
     "ci-info": "^4.2.0",
     "cloudflare": "^4.4.1",
     "comment-json": "^4.5.1",
@@ -70,7 +70,7 @@
     "eslint-plugin-unicorn": "^55.0.0",
     "globals": "^15.9.0",
     "mock-fs": "^5.4.1",
-    "next": "^15.5.18",
+    "next": "^15.5.24",
     "picomatch": "^4.0.2",
     "rclone.js": "^0.6.6",
     "rimraf": "^6.0.1",
@@ -79,9 +79,9 @@
     "vitest": "^4.1.4"
   },
   "peerDependencies": {
-    "next": ">=15.5.18 <16 || >=16.2.6",
+    "next": ">=15.5.24 <16 || >=16.3.3",
     "rclone.js": "^0.6.6",
-    "wrangler": "^4.86.0"
+    "wrangler": "^4.125.0"
   },
   "peerDependenciesMeta": {
     "rclone.js": {