@opennextjs/cloudflare 1.19.4 → 1.19.6

package/dist/api/durable-objects/queue.js

@@ -21,10 +21,11 @@ export class DOQueueHandler extends DurableObject {
     disableSQLite;
     constructor(ctx, env) {
         super(ctx, env);
-        this.service = env.WORKER_SELF_REFERENCE;
         // If there is no service binding, we throw an error because we can't revalidate without it
-        if (!this.service)
+        if (!env.WORKER_SELF_REFERENCE) {
             throw new IgnorableError("No service binding for cache revalidation worker");
+        }
+        this.service = env.WORKER_SELF_REFERENCE;
         this.sql = ctx.storage.sql;
         this.maxRevalidations = env.NEXT_CACHE_DO_QUEUE_MAX_REVALIDATION
             ? parseInt(env.NEXT_CACHE_DO_QUEUE_MAX_REVALIDATION)

package/dist/api/overrides/tag-cache/tag-cache-filter.d.ts

@@ -10,7 +10,7 @@ interface WithFilterOptions {
      * @param tag The tag to filter.
      * @returns true if the tag should be forwarded, false otherwise.
      */
-    filterFn: (tag: string | NextModeTagCacheWriteInput) => boolean;
+    filterFn: (tag: NextModeTagCacheWriteInput) => boolean;
 }
 /**
  * Creates a new tag cache that filters tags based on the provided filter function.
@@ -22,5 +22,5 @@ export declare function withFilter({ tagCache, filterFn }: WithFilterOptions): N
  * This is used to filter out internal soft tags.
  * Can be used if `revalidatePath` is not used.
  */
-export declare function softTagFilter(tag: string | NextModeTagCacheWriteInput): boolean;
+export declare function softTagFilter(tag: NextModeTagCacheWriteInput): boolean;
 export {};

package/dist/cli/build/build.js

@@ -38,6 +38,19 @@ export async function build(options, config, projectOpts, wranglerConfig, allowU
     const { aws, cloudflare } = getVersion();
     logger.info(`@opennextjs/cloudflare version: ${cloudflare}`);
     logger.info(`@opennextjs/aws version: ${aws}`);
+    if (wranglerConfig.compatibility_date) {
+        const sixMonthsAgoMs = Date.now() - 6 * 30 * 24 * 60 * 60 * 1000;
+        const compatDateMs = new Date(wranglerConfig.compatibility_date).getTime();
+        if (!isNaN(compatDateMs)) {
+            const dateMessage = `workerd compatibility_date: ${wranglerConfig.compatibility_date}`;
+            if (compatDateMs < sixMonthsAgoMs) {
+                logger.warn(`${dateMessage}, consider updating your wrangler config to a more recent date to benefit from the latest features and fixes.`);
+            }
+            else {
+                logger.info(`${dateMessage}`);
+            }
+        }
+    }
     // Clean the output directory before building the Next app.
     buildHelper.initOutputDir(options);
     if (projectOpts.skipNextBuild) {

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/migrate.js

@@ -97,13 +97,20 @@ async function migrateCommand(args) {
     }
     catch (error) {
         logger.error("Failed to update package.json", error.message);
-        logger.warn("\nPlease ensure that your package.json contains the following scripts:\n" +
-            console.log([...Object.entries(openNextScripts)].map(([key, value]) => ` - ${key}: ${value}`).join("\n")) +
-            "\n");
+        logger.warn(`Please ensure that your package.json contains the following scripts:
+${[...Object.entries(openNextScripts)].map(([k, v]) => ` - ${k}: ${v}`).join("\n")}
+`);
     }
     const gitIgnoreExists = fs.existsSync(".gitignore");
     printStepTitle(`${gitIgnoreExists ? "Updating" : "Creating"} .gitignore file`);
-    conditionalAppendFileSync(".gitignore", "# OpenNext\n.open-next\n", {
+    conditionalAppendFileSync(".gitignore", `# OpenNext
+.open-next
+
+# wrangler files
+.wrangler
+.dev.vars*
+!.dev.vars.example
+`, {
         appendIf: (content) => !content.includes(".open-next"),
         appendPrefix: "\n",
     });

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/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-02-01") {
+export async function createWranglerConfigFile(projectDir, defaultCompatDate = "2026-04-15") {
     const workerName = getWorkerName(projectDir);
     const compatibilityDate = (await getLatestCompatDate()) ?? defaultCompatDate;
     const wranglerConfigStr = readFileSync(join(getPackageTemplatesDirPath(), "wrangler.jsonc"), "utf8")

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "1.19.4",
+  "version": "1.19.6",
   "type": "module",
   "bin": {
     "opennextjs-cloudflare": "dist/cli/index.js"
@@ -78,7 +78,7 @@
   },
   "peerDependencies": {
     "next": ">=15.5.15 <16 || >=16.2.3",
-    "wrangler": "^4.84.1"
+    "wrangler": "^4.86.0"
   },
   "scripts": {
     "clean": "rimraf dist",