@opennextjs/cloudflare 1.19.5 → 1.19.6

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

@@ -1,2 +1,27 @@
 import type { CodePatcher } from "@opennextjs/aws/build/patch/codePatcher.js";
+/**
+ * Replace Turbopack's `loadWebAssemblyModule` with a call to our generated `loadWasmChunk`.
+ *
+ * The original implementation uses `WebAssembly.compileStreaming`, which is not available
+ * in workerd. `loadWasmChunk` resolves the chunk via a static `import()` switch so the
+ * bundler can statically discover and bundle each `.wasm` chunk.
+ */
+export declare const replaceLoadWebAssemblyModuleRule = "\nrule:\n  kind: function_declaration\n  has:\n    field: name\n    regex: \"^loadWebAssemblyModule$\"\nfix: |-\n  function loadWebAssemblyModule(chunkPath, _edgeModule) {\n    return loadWasmChunk(chunkPath);\n  }\n";
+/**
+ * Replace Turbopack's `loadWebAssembly` with a synchronous-instantiation variant.
+ *
+ * The original implementation uses `WebAssembly.instantiateStreaming`, which is not
+ * available in workerd. We load the compiled module via `loadWasmChunk` and then call
+ * 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";
 export declare const patchTurbopackRuntime: CodePatcher;
+/**
+ * Generate a `loadWasmChunk` function that maps a `.next`-relative chunk path to a
+ * statically-importable `.wasm` module.
+ *
+ * The replacement rules for Turbopack's `loadWebAssembly{,Module}` delegate to this
+ * function. Because the imports are emitted as string literals, the bundler can
+ * statically discover every wasm chunk and include them in the final build.
+ */
+export declare function loadWasmChunkFn(tracedFiles: string[]): string;

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

@@ -9,6 +9,44 @@ rule:
 fix:
   requireChunk(chunkPath)
 `;
+/**
+ * Replace Turbopack's `loadWebAssemblyModule` with a call to our generated `loadWasmChunk`.
+ *
+ * The original implementation uses `WebAssembly.compileStreaming`, which is not available
+ * in workerd. `loadWasmChunk` resolves the chunk via a static `import()` switch so the
+ * bundler can statically discover and bundle each `.wasm` chunk.
+ */
+export const replaceLoadWebAssemblyModuleRule = `
+rule:
+  kind: function_declaration
+  has:
+    field: name
+    regex: "^loadWebAssemblyModule$"
+fix: |-
+  function loadWebAssemblyModule(chunkPath, _edgeModule) {
+    return loadWasmChunk(chunkPath);
+  }
+`;
+/**
+ * Replace Turbopack's `loadWebAssembly` with a synchronous-instantiation variant.
+ *
+ * The original implementation uses `WebAssembly.instantiateStreaming`, which is not
+ * available in workerd. We load the compiled module via `loadWasmChunk` and then call
+ * the synchronous `WebAssembly.instantiate` to produce the instance's exports.
+ */
+export const replaceLoadWebAssemblyRule = `
+rule:
+  kind: function_declaration
+  has:
+    field: name
+    regex: "^loadWebAssembly$"
+fix: |-
+  async function loadWebAssembly(chunkPath, _edgeModule, imports) {
+    const mod = await loadWasmChunk(chunkPath);
+    const { exports } = await WebAssembly.instantiate(mod, imports);
+    return exports;
+  }
+`;
 /**
  * Discover Turbopack external module mappings by reading symlinks in .next/node_modules/.
  *
@@ -196,7 +234,10 @@ export const patchTurbopackRuntime = {
                 const externalImportRule = buildExternalImportRule(mappings, tracedFiles, code);
                 let patched = patchCode(code, externalImportRule);
                 patched = patchCode(patched, inlineChunksRule);
-                return `${patched}\n${inlineChunksFn(tracedFiles)}`;
+                patched = patchCode(patched, replaceLoadWebAssemblyModuleRule);
+                patched = patchCode(patched, replaceLoadWebAssemblyRule);
+                return `${patched}
+${inlineChunksFn(tracedFiles)}\n${loadWasmChunkFn(tracedFiles)}`;
             },
         },
     ],
@@ -230,3 +271,27 @@ ${chunks
   }
 `;
 }
+/**
+ * Generate a `loadWasmChunk` function that maps a `.next`-relative chunk path to a
+ * statically-importable `.wasm` module.
+ *
+ * The replacement rules for Turbopack's `loadWebAssembly{,Module}` delegate to this
+ * function. Because the imports are emitted as string literals, the bundler can
+ * statically discover every wasm chunk and include them in the final build.
+ */
+export function loadWasmChunkFn(tracedFiles) {
+    const wasmFiles = tracedFiles.filter((f) => f.endsWith(".wasm"));
+    const cases = wasmFiles
+        .map((absPath) => ({ absPath, relPath: absPath.replace(/.*\/\.next\//, "") }))
+        .map(({ absPath, relPath }) => `      case "${relPath}": return (await import("${absPath}")).default;`)
+        .join("\n");
+    return `
+  async function loadWasmChunk(chunkPath) {
+    switch (chunkPath) {
+${cases}
+      default:
+        throw new Error(\`Unknown wasm chunk: \${chunkPath}\`);
+    }
+  }
+`;
+}

package/dist/cli/build/utils/workerd.js

@@ -14,24 +14,23 @@ import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
  */
 export function transformBuildCondition(conditionMap, condition) {
     const transformed = {};
-    const hasTopLevelBuildCondition = Object.keys(conditionMap).some((key) => key === condition && typeof conditionMap[key] === "string");
+    const hasTopLevelBuildCondition = condition in conditionMap && conditionMap[condition] != null;
     let hasBuildCondition = hasTopLevelBuildCondition;
     for (const [key, value] of Object.entries(conditionMap)) {
         if (typeof value === "object" && value != null) {
             const { transformedExports, hasBuildCondition: innerBuildCondition } = transformBuildCondition(value, condition);
+            // If a build condition is present at this level but a sibling
+            // subtree doesn't contain the build condition, we can drop it entirely.
+            if (hasTopLevelBuildCondition && key !== condition && !innerBuildCondition) {
+                continue;
+            }
             transformed[key] = transformedExports;
             hasBuildCondition ||= innerBuildCondition;
         }
-        else {
-            // If it doesn't have the build condition, we need to keep everything as is
-            // If it has the build condition, we need to keep only the build condition
-            // and remove everything else
-            if (!hasTopLevelBuildCondition) {
-                transformed[key] = value;
-            }
-            else if (key === condition) {
-                transformed[key] = value;
-            }
+        else if (!hasTopLevelBuildCondition || key === condition) {
+            // If there is no build condition at this level or this is a non-object build condition,
+            // we need to keep the child condition as is.
+            transformed[key] = value;
         }
     }
     return { transformedExports: transformed, hasBuildCondition };

package/dist/cli/commands/populate-cache.js

@@ -404,7 +404,8 @@ function populateD1TagCache(buildOpts, config, populateCacheOptions) {
         target: populateCacheOptions.target,
         environment: populateCacheOptions.environment,
         configPath: populateCacheOptions.wranglerConfigPath,
-        logging: "error",
+        // Do not log errors since the ALTER TABLE command will fail if the columns already exist.
+        logging: "none",
     });
     logger.info("\nSuccessfully created D1 table");
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "1.19.5",
+  "version": "1.19.6",
   "type": "module",
   "bin": {
     "opennextjs-cloudflare": "dist/cli/index.js"