@opennextjs/cloudflare 1.19.5 → 1.19.7

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.d.ts

@@ -4,6 +4,10 @@ import type { Unstable_Config as WranglerConfig } from "wrangler";
 import type yargs from "yargs";
 import { type WorkerEnvVar } from "./utils/helpers.js";
 import type { WranglerTarget } from "./utils/run-wrangler.js";
+export declare const MAX_REQUEST_RETRIES = 15;
+export declare const BASE_RETRY_DELAY_MS = 250;
+export declare const MAX_RETRY_DELAY_MS = 10000;
+export declare const BACKOFF_FACTOR: number;
 export declare function populateCache(buildOpts: BuildOptions, config: OpenNextConfig, wranglerConfig: WranglerConfig, populateCacheOptions: PopulateCacheOptions, envVars: WorkerEnvVar): Promise<void>;
 export type CacheAsset = {
     isFetch: boolean;

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

@@ -19,6 +19,14 @@ import { normalizePath } from "../utils/normalize-path.js";
 import { getEnvFromPlatformProxy, quoteShellMeta } from "./utils/helpers.js";
 import { runWrangler } from "./utils/run-wrangler.js";
 import { getNormalizedOptions, printHeaders, readWranglerConfig, retrieveCompiledConfig, withWranglerOptions, withWranglerPassthroughArgs, } from "./utils/utils.js";
+// Maximum number of attempts to send the request
+export const MAX_REQUEST_RETRIES = 15;
+// Base delay for retries
+export const BASE_RETRY_DELAY_MS = 250;
+// Maximum delay for retries, used to calculate the backoff factor
+export const MAX_RETRY_DELAY_MS = 10_000;
+// Backoff factor for retries, calculated to ensure that the delay grows exponentially up to the maximum delay
+export const BACKOFF_FACTOR = (MAX_RETRY_DELAY_MS / BASE_RETRY_DELAY_MS) ** (1 / (MAX_REQUEST_RETRIES - 1));
 /**
  * Implementation of the `opennextjs-cloudflare populateCache` command.
  *
@@ -199,49 +207,32 @@ async function populateR2IncrementalCache(buildOpts, config, populateCacheOption
 /**
  * Sends cache entries to the R2 worker, one entry per request.
  *
- * Up to `concurrency` requests are in-flight at any given time.
- * Retry logic for transient R2 write failures is handled by the worker.
- *
  * @param options
  * @param options.workerUrl - The URL of the local R2 worker's `/populate` endpoint.
  * @param options.assets - The cache assets to write, as collected by {@link getCacheAssets}.
  * @param options.prefix - Optional prefix prepended to each R2 key.
- * @param options.concurrency - Maximum number of concurrent in-flight requests.
+ * @param options.maxConcurrency - Maximum number of concurrent in-flight requests.
  * @returns Resolves when all entries have been written successfully.
  * @throws {Error} If any entry fails after all retries or encounters a non-retryable error.
  */
 async function sendEntriesToR2Worker(options) {
     const { workerUrl, assets, prefix, maxConcurrency } = options;
-    // Build the list of entries to send (key + filename).
-    // File contents are read lazily in sendEntryToR2Worker to avoid
-    // loading all cache values into memory at once.
-    const entries = assets.map(({ fullPath, key, buildId, isFetch }) => ({
-        key: computeCacheKey(key, {
-            prefix,
-            buildId,
-            cacheType: isFetch ? "fetch" : "cache",
-        }),
-        filename: fullPath,
-    }));
-    // Use a concurrency-limited loop with a progress bar.
-    // `pending` tracks in-flight promises so we can cap concurrency.
     const pending = new Set();
-    let concurrency = 1;
-    for (const entry of tqdm(entries)) {
+    for (const asset of tqdm(assets)) {
+        const { fullPath, key, buildId, isFetch } = asset;
         const task = sendEntryToR2Worker({
             workerUrl,
-            key: entry.key,
-            filename: entry.filename,
+            key: computeCacheKey(key, {
+                prefix,
+                buildId,
+                cacheType: isFetch ? "fetch" : "cache",
+            }),
+            filename: fullPath,
         }).finally(() => pending.delete(task));
         pending.add(task);
         // If we've reached the concurrency limit, wait for one to finish.
-        if (pending.size >= concurrency) {
+        if (pending.size >= maxConcurrency) {
             await Promise.race(pending);
-            // Increase concurrency gradually to avoid overwhelming the worker
-            // with too many requests at once.
-            if (concurrency < maxConcurrency) {
-                concurrency++;
-            }
         }
     }
     await Promise.all(pending);
@@ -261,9 +252,7 @@ class RetryableWorkerError extends Error {
  */
 async function sendEntryToR2Worker(options) {
     const { workerUrl, key, filename } = options;
-    const CLIENT_RETRY_ATTEMPTS = 5;
-    const CLIENT_RETRY_BASE_DELAY_MS = 250;
-    for (let attempt = 0; attempt < CLIENT_RETRY_ATTEMPTS; attempt++) {
+    for (let attempt = 0; attempt < MAX_REQUEST_RETRIES; attempt++) {
         try {
             let response;
             try {
@@ -280,9 +269,7 @@ async function sendEntryToR2Worker(options) {
                 });
             }
             catch (e) {
-                throw new RetryableWorkerError(`Failed to send request to R2 worker: ${e instanceof Error ? e.message : String(e)}`, {
-                    cause: e,
-                });
+                throw new RetryableWorkerError(`Failed to send request to R2 worker: ${e instanceof Error ? e.message : String(e)}`, { cause: e });
             }
             const body = await response.text();
             let result;
@@ -290,6 +277,7 @@ async function sendEntryToR2Worker(options) {
                 result = JSON.parse(body);
             }
             catch (e) {
+                // https://developers.cloudflare.com/support/troubleshooting/http-status-codes/cloudflare-1xxx-errors/error-1102
                 if (body.includes("Worker exceeded resource limits")) {
                     throw new RetryableWorkerError("Worker exceeded resource limits", { cause: e });
                 }
@@ -300,21 +288,20 @@ async function sendEntryToR2Worker(options) {
                     cause: e,
                 });
             }
-            if (!result.success && response.status >= 500) {
-                throw new RetryableWorkerError(result.error);
-            }
             if (!result.success) {
-                throw new Error(`Failed to write "${key}" to R2: ${result.error}`);
+                throw response.status >= 500
+                    ? new RetryableWorkerError(result.error)
+                    : new Error(`Failed to write "${key}" to R2: ${result.error}`);
             }
             return;
         }
         catch (e) {
-            if (e instanceof RetryableWorkerError && attempt < CLIENT_RETRY_ATTEMPTS - 1) {
+            if (e instanceof RetryableWorkerError && attempt < MAX_REQUEST_RETRIES - 1) {
                 logger.error(`Attempt ${attempt + 1} to write "${key}" failed with a retryable error: ${e.message}. Retrying...`);
-                await setTimeout(CLIENT_RETRY_BASE_DELAY_MS * Math.pow(2, attempt));
+                await setTimeout(BASE_RETRY_DELAY_MS * Math.pow(BACKOFF_FACTOR, attempt));
                 continue;
             }
-            throw new Error(`Failed to write "${key}" to R2 after ${CLIENT_RETRY_ATTEMPTS} attempts`, {
+            throw new Error(`Failed to write "${key}" to R2 after ${MAX_REQUEST_RETRIES} attempts`, {
                 cause: e,
             });
         }
@@ -404,7 +391,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.7",
   "type": "module",
   "bin": {
     "opennextjs-cloudflare": "dist/cli/index.js"
@@ -54,7 +54,7 @@
     "yargs": "^18.0.0"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20260423.1",
+    "@cloudflare/workers-types": "^4.20260426.1",
     "@eslint/js": "^9.11.1",
     "@tsconfig/strictest": "^2.0.5",
     "@types/mock-fs": "^4.13.4",
@@ -69,7 +69,7 @@
     "eslint-plugin-unicorn": "^55.0.0",
     "globals": "^15.9.0",
     "mock-fs": "^5.4.1",
-    "next": "~15.5.15",
+    "next": "^15.5.16",
     "picomatch": "^4.0.2",
     "rimraf": "^6.0.1",
     "typescript": "^5.9.3",
@@ -77,7 +77,7 @@
     "vitest": "^4.1.4"
   },
   "peerDependencies": {
-    "next": ">=15.5.15 <16 || >=16.2.3",
+    "next": ">=15.5.16 <16 || >=16.2.5",
     "wrangler": "^4.86.0"
   },
   "scripts": {