@opennextjs/cloudflare 1.11.1 → 1.13.0

package/README.md

@@ -55,30 +55,3 @@ Deploy your application to production with the following:
   # or
   bun opennextjs-cloudflare build && bun opennextjs-cloudflare deploy
   ```
-
-### Batch Cache Population (Optional, Recommended)
-
-For improved performance with large caches, you can enable batch upload by providing R2 credentials via .env or environment variables.
-
-Create a `.env` file in your project root (automatically loaded by the CLI):
-
-```bash
-R2_ACCESS_KEY_ID=your_access_key_id
-R2_SECRET_ACCESS_KEY=your_secret_access_key
-CF_ACCOUNT_ID=your_account_id
-```
-
-You can also set the environment variables for CI builds.
-
-**Note:**
-
-You can follow documentation https://developers.cloudflare.com/r2/api/tokens/ for creating API tokens with appropriate permissions for R2 access.
-
-**Benefits:**
-
-- Significantly faster uploads for large caches using parallel transfers
-- Reduced API calls to Cloudflare
-- Automatically enabled when credentials are provided
-
-**Fallback:**
-If these environment variables are not set, the CLI will use standard Wrangler uploads. Both methods work correctly - batch upload is simply faster for large caches.

package/dist/api/cloudflare-context.d.ts

@@ -31,8 +31,6 @@ declare global {
         CF_PREVIEW_DOMAIN?: string;
         CF_WORKERS_SCRIPTS_API_TOKEN?: string;
         CF_ACCOUNT_ID?: string;
-        R2_ACCESS_KEY_ID?: string;
-        R2_SECRET_ACCESS_KEY?: string;
     }
 }
 export type CloudflareContext<CfProperties extends Record<string, unknown> = IncomingRequestCfProperties, Context = ExecutionContext> = {

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

@@ -43,9 +43,10 @@ const optionalDependencies = [
 export async function bundleServer(buildOpts, projectOpts) {
     copyPackageCliFiles(packageDistDir, buildOpts);
     const { appPath, outputDir, monorepoRoot, debug } = buildOpts;
-    const baseManifestPath = path.join(outputDir, "server-functions/default", getPackagePath(buildOpts), ".next");
-    const serverFiles = path.join(baseManifestPath, "required-server-files.json");
+    const dotNextPath = path.join(outputDir, "server-functions/default", getPackagePath(buildOpts), ".next");
+    const serverFiles = path.join(dotNextPath, "required-server-files.json");
     const nextConfig = JSON.parse(fs.readFileSync(serverFiles, "utf-8")).config;
+    const useTurbopack = fs.existsSync(path.join(dotNextPath, "server/chunks/[turbopack]_runtime.js"));
     console.log(`\x1b[35m⚙️ Bundling the OpenNext server...\n\x1b[0m`);
     await patchWebpackRuntime(buildOpts);
     patchVercelOgLibrary(buildOpts);
@@ -118,13 +119,12 @@ export async function bundleServer(buildOpts, projectOpts) {
             // Note: we need the __non_webpack_require__ variable declared as it is used by next-server:
             // https://github.com/vercel/next.js/blob/be0c3283/packages/next/src/server/next-server.ts#L116-L119
             __non_webpack_require__: "require",
+            // The 2 following defines are used to reduce the bundle size by removing unnecessary code
+            // Next uses different precompiled renderers (i.e. `app-page.runtime.prod.js`) based on if you use `TURBOPACK` or some experimental React features
+            ...(useTurbopack ? {} : { "process.env.TURBOPACK": "false" }),
             // We make sure that environment variables that Next.js expects are properly defined
             "process.env.NEXT_RUNTIME": '"nodejs"',
             "process.env.NODE_ENV": '"production"',
-            // The 2 following defines are used to reduce the bundle size by removing unnecessary code
-            // Next uses different precompiled renderers (i.e. `app-page.runtime.prod.js`) based on if you use `TURBOPACK` or some experimental React features
-            // Turbopack is not supported for build at the moment, so we disable it
-            "process.env.TURBOPACK": "false",
             // This define should be safe to use for Next 14.2+, earlier versions (13.5 and less) will cause trouble
             "process.env.__NEXT_EXPERIMENTAL_REACT": `${needsExperimentalReact(nextConfig)}`,
             // Fix `res.validate` in Next 15.4 (together with the `route-module` patch)

package/dist/cli/build/open-next/createServerBundle.js

@@ -20,6 +20,7 @@ import { openNextResolvePlugin } from "@opennextjs/aws/plugins/resolve.js";
 import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
 import { getOpenNextConfig } from "../../../api/config.js";
 import { patchResRevalidate } from "../patches/plugins/res-revalidate.js";
+import { patchTurbopackRuntime } from "../patches/plugins/turbopack.js";
 import { patchUseCacheIO } from "../patches/plugins/use-cache.js";
 import { normalizePath } from "../utils/index.js";
 import { copyWorkerdPackages } from "../utils/workerd.js";
@@ -142,6 +143,7 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
         // Cloudflare specific patches
         patchResRevalidate,
         patchUseCacheIO,
+        patchTurbopackRuntime,
         ...additionalCodePatches,
     ]);
     // Build Lambda code

package/dist/cli/build/patches/ast/patch-vercel-og-library.js

@@ -16,6 +16,7 @@ export function patchVercelOgLibrary(buildOpts) {
     for (const traceInfoPath of globSync(path.join(appBuildOutputPath, ".next/server/**/*.nft.json"), {
         windowsPathsNoEscape: true,
     })) {
+        let edgeFilePatched = false;
         const traceInfo = JSON.parse(readFileSync(traceInfoPath, { encoding: "utf8" }));
         const tracedNodePath = traceInfo.files.find((p) => p.endsWith("@vercel/og/index.node.js"));
         if (!tracedNodePath)
@@ -26,14 +27,20 @@ export function patchVercelOgLibrary(buildOpts) {
         if (!existsSync(outputEdgePath)) {
             const tracedEdgePath = path.join(path.dirname(traceInfoPath), tracedNodePath.replace("index.node.js", "index.edge.js"));
             copyFileSync(tracedEdgePath, outputEdgePath);
+        }
+        if (!edgeFilePatched) {
+            edgeFilePatched = true;
             // Change font fetches in the library to use imports.
             const node = parseFile(outputEdgePath);
             const { edits, matches } = patchVercelOgFallbackFont(node);
             writeFileSync(outputEdgePath, node.commitEdits(edits));
-            const fontFileName = matches[0].getMatch("PATH").text();
-            renameSync(path.join(outputDir, fontFileName), path.join(outputDir, `${fontFileName}.bin`));
+            if (matches.length > 0) {
+                const fontFileName = matches[0].getMatch("PATH").text();
+                renameSync(path.join(outputDir, fontFileName), path.join(outputDir, `${fontFileName}.bin`));
+            }
         }
         // Change node imports for the library to edge imports.
+        // This is only useful when turbopack is not used to bundle the function.
         const routeFilePath = traceInfoPath.replace(appBuildOutputPath, packagePath).replace(".nft.json", "");
         const node = parseFile(routeFilePath);
         const { edits } = patchVercelOgImport(node);

package/dist/cli/build/patches/ast/vercel-og.d.ts

@@ -7,7 +7,7 @@ export declare const vercelOgImportRule = "\nrule:\n  pattern: $NODE\n  kind: st
  * @returns Results of applying the rule.
  */
 export declare function patchVercelOgImport(root: SgNode): {
-    edits: import("@opennextjs/aws/build/patch/astCodePatcher").Edit[];
+    edits: import("@ast-grep/napi/types/sgnode").Edit[];
     matches: SgNode[];
 };
 export declare const vercelOgFallbackFontRule = "\nrule:\n  kind: variable_declaration\n  all:\n    - has:\n        kind: variable_declarator\n        has:\n          kind: identifier\n          regex: ^fallbackFont$\n    - has:\n        kind: call_expression\n        pattern: fetch(new URL(\"$PATH\", $$$REST))\n        stopBy: end\n\nfix: |-\n  async function getFallbackFont() {\n    // .bin is used so that a loader does not need to be configured for .ttf files\n    return (await import(\"$PATH.bin\")).default;\n  }\n\n  var fallbackFont = getFallbackFont();\n";
@@ -18,6 +18,6 @@ export declare const vercelOgFallbackFontRule = "\nrule:\n  kind: variable_decla
  * @returns Results of applying the rule.
  */
 export declare function patchVercelOgFallbackFont(root: SgNode): {
-    edits: import("@opennextjs/aws/build/patch/astCodePatcher").Edit[];
+    edits: import("@ast-grep/napi/types/sgnode").Edit[];
     matches: SgNode[];
 };

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

@@ -0,0 +1,2 @@
+import type { CodePatcher } from "@opennextjs/aws/build/patch/codePatcher.js";
+export declare const patchTurbopackRuntime: CodePatcher;

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

@@ -0,0 +1,78 @@
+import { patchCode } from "@opennextjs/aws/build/patch/astCodePatcher.js";
+import { getCrossPlatformPathRegex } from "@opennextjs/aws/utils/regex.js";
+const inlineChunksRule = `
+rule:
+  kind: call_expression
+  pattern: require(resolved)
+fix:
+  requireChunk(chunkPath)
+`;
+export const patchTurbopackRuntime = {
+    name: "inline-turbopack-chunks",
+    patches: [
+        {
+            versions: ">=15.0.0",
+            pathFilter: getCrossPlatformPathRegex(String.raw `\[turbopack\]_runtime\.js$`, {
+                escape: false,
+            }),
+            contentFilter: /loadRuntimeChunkPath/,
+            patchCode: async ({ code, tracedFiles }) => {
+                let patched = patchCode(code, inlineExternalImportRule);
+                patched = patchCode(patched, inlineChunksRule);
+                return `${patched}\n${inlineChunksFn(tracedFiles)}`;
+            },
+        },
+    ],
+};
+function getInlinableChunks(tracedFiles) {
+    const chunks = new Set();
+    for (const file of tracedFiles) {
+        if (file === "[turbopack]_runtime.js") {
+            continue;
+        }
+        if (file.includes(".next/server/chunks/")) {
+            chunks.add(file);
+        }
+    }
+    return Array.from(chunks);
+}
+function inlineChunksFn(tracedFiles) {
+    // From the outputs, we extract every chunks
+    const chunks = getInlinableChunks(tracedFiles);
+    return `
+  function requireChunk(chunkPath) {
+    switch(chunkPath) {
+${chunks
+        .map((chunk) => `      case "${
+    // we only want the path after /path/to/.next/
+    chunk.replace(/.*\/\.next\//, "")}": return require("${chunk}");`)
+        .join("\n")}
+      default:
+        throw new Error(\`Not found \${chunkPath}\`);
+    }
+  }
+`;
+}
+// Turbopack imports `og` via `externalImport`.
+// We patch it to:
+// - add the explicit path so that the file is inlined by wrangler
+// - use the edge version of the module instead of the node version.
+//
+// Modules that are not inlined (no added to the switch), would generate an error similar to:
+// Failed to load external module path/to/module: Error: No such module "path/to/module"
+const inlineExternalImportRule = `
+rule:
+  pattern: "$RAW = await import($ID)"
+  inside:
+    regex: "externalImport"
+    kind: function_declaration
+    stopBy: end
+fix: |-
+  switch ($ID) {
+    case "next/dist/compiled/@vercel/og/index.node.js":
+      $RAW = await import("next/dist/compiled/@vercel/og/index.edge.js");
+      break;
+    default:
+      $RAW = await import($ID);
+  }
+`;

package/dist/cli/commands/populate-cache.d.ts

@@ -28,7 +28,7 @@ type PopulateCacheOptions = {
     /**
      * Chunk sizes to use when populating KV cache. Ignored for R2.
      *
-     * @default 25 for KV
+     * @default 25 for KV, 50 for R2
      */
     cacheChunkSize?: number;
     /**

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

@@ -1,9 +1,9 @@
-import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import logger from "@opennextjs/aws/logger.js";
 import { globSync } from "glob";
-import rclone from "rclone.js";
 import { tqdm } from "ts-tqdm";
 import { BINDING_NAME as KV_CACHE_BINDING_NAME, NAME as KV_CACHE_NAME, PREFIX_ENV_NAME as KV_CACHE_PREFIX_ENV_NAME, } from "../../api/overrides/incremental-cache/kv-incremental-cache.js";
 import { BINDING_NAME as R2_CACHE_BINDING_NAME, NAME as R2_CACHE_NAME, PREFIX_ENV_NAME as R2_CACHE_PREFIX_ENV_NAME, } from "../../api/overrides/incremental-cache/r2-incremental-cache.js";
@@ -35,7 +35,7 @@ async function populateCacheCommand(target, args) {
 }
 export async function populateCache(buildOpts, config, wranglerConfig, populateCacheOptions, envVars) {
     const { incrementalCache, tagCache } = config.default.override ?? {};
-    if (!existsSync(buildOpts.outputDir)) {
+    if (!fs.existsSync(buildOpts.outputDir)) {
         logger.error("Unable to populate cache: Open Next build not found");
         process.exit(1);
     }
@@ -74,10 +74,11 @@ export function getCacheAssets(opts) {
         withFileTypes: true,
         windowsPathsNoEscape: true,
     }).filter((f) => f.isFile());
+    const baseCacheDir = path.join(opts.outputDir, "cache");
     const assets = [];
     for (const file of allFiles) {
         const fullPath = file.fullpath();
-        const relativePath = normalizePath(path.relative(path.join(opts.outputDir, "cache"), fullPath));
+        const relativePath = normalizePath(path.relative(baseCacheDir, fullPath));
         if (relativePath.startsWith("__fetch")) {
             const [__fetch, buildId, ...keyParts] = relativePath.split("/");
             if (__fetch !== "__fetch" || buildId === undefined || keyParts.length === 0) {
@@ -105,133 +106,6 @@ export function getCacheAssets(opts) {
     }
     return assets;
 }
-/**
- * Create a temporary configuration file for batch upload from environment variables
- * @returns Path to the temporary config file or null if env vars not available
- */
-function createTempRcloneConfig(accessKey, secretKey, accountId) {
-    const tempDir = tmpdir();
-    const tempConfigPath = path.join(tempDir, `rclone-config-${Date.now()}.conf`);
-    const configContent = `[r2]
-type = s3
-provider = Cloudflare
-access_key_id = ${accessKey}
-secret_access_key = ${secretKey}
-endpoint = https://${accountId}.r2.cloudflarestorage.com
-acl = private
-`;
-    /**
-     * 0o600 is an octal number (the 0o prefix indicates octal in JavaScript)
-     * that represents Unix file permissions:
-     *
-     * - 6 (owner): read (4) + write (2) = readable and writable by the file owner
-     * - 0 (group): no permissions for the group
-     * - 0 (others): no permissions for anyone else
-     *
-     * In symbolic notation, this is: rw-------
-     */
-    writeFileSync(tempConfigPath, configContent, { mode: 0o600 });
-    return tempConfigPath;
-}
-/**
- * Populate R2 incremental cache using batch upload for better performance
- * Uses parallel transfers to significantly speed up cache population
- */
-async function populateR2IncrementalCacheWithBatchUpload(bucket, prefix, assets, envVars) {
-    const accessKey = envVars.R2_ACCESS_KEY_ID || null;
-    const secretKey = envVars.R2_SECRET_ACCESS_KEY || null;
-    const accountId = envVars.CF_ACCOUNT_ID || null;
-    // Ensure all required env vars are set correctly
-    if (!accessKey || !secretKey || !accountId) {
-        throw new Error("Please set R2_ACCESS_KEY_ID, R2_SECRET_ACCESS_KEY, and CF_ACCOUNT_ID environment variables to enable faster batch upload for remote R2.");
-    }
-    logger.info("\nPopulating remote R2 incremental cache using batch upload...");
-    // Create temporary config from env vars - required for batch upload
-    const tempConfigPath = createTempRcloneConfig(accessKey, secretKey, accountId);
-    if (!tempConfigPath) {
-        throw new Error("Failed to create temporary rclone config for R2 batch upload.");
-    }
-    const env = {
-        ...process.env,
-        RCLONE_CONFIG: tempConfigPath,
-    };
-    logger.info("Using batch upload with R2 credentials from environment variables");
-    // Create a staging dir in temp directory with proper key paths
-    const tempDir = tmpdir();
-    const stagingDir = path.join(tempDir, `.r2-staging-${Date.now()}`);
-    // Track success to ensure cleanup happens correctly
-    let success = null;
-    try {
-        mkdirSync(stagingDir, { recursive: true });
-        for (const { fullPath, key, buildId, isFetch } of assets) {
-            const cacheKey = computeCacheKey(key, {
-                prefix,
-                buildId,
-                cacheType: isFetch ? "fetch" : "cache",
-            });
-            const destPath = path.join(stagingDir, cacheKey);
-            mkdirSync(path.dirname(destPath), { recursive: true });
-            copyFileSync(fullPath, destPath);
-        }
-        // Use rclone.js to sync the R2
-        const remote = `r2:${bucket}`;
-        // Using rclone.js Promise-based API for the copy operation
-        await rclone.promises.copy(stagingDir, remote, {
-            progress: true,
-            transfers: 16,
-            checkers: 8,
-            env,
-        });
-        logger.info(`Successfully uploaded ${assets.length} assets to R2 using batch upload`);
-        success = true;
-    }
-    finally {
-        try {
-            // Cleanup temporary staging directory
-            rmSync(stagingDir, { recursive: true, force: true });
-        }
-        catch {
-            console.warn(`Failed to remove temporary staging directory at ${stagingDir}`);
-        }
-        try {
-            // Cleanup temporary config file
-            rmSync(tempConfigPath);
-        }
-        catch {
-            console.warn(`Failed to remove temporary config at ${tempConfigPath}`);
-        }
-    }
-    if (!success) {
-        throw new Error("R2 batch upload failed, falling back to sequential uploads...");
-    }
-}
-/**
- * Populate R2 incremental cache using sequential Wrangler uploads
- * Falls back to this method when batch upload is not available or fails
- */
-async function populateR2IncrementalCacheWithSequentialUpload(buildOpts, bucket, prefix, assets, populateCacheOptions) {
-    logger.info("Using sequential cache uploads.");
-    for (const { fullPath, key, buildId, isFetch } of tqdm(assets)) {
-        const cacheKey = computeCacheKey(key, {
-            prefix,
-            buildId,
-            cacheType: isFetch ? "fetch" : "cache",
-        });
-        runWrangler(buildOpts, [
-            "r2 object put",
-            quoteShellMeta(normalizePath(path.join(bucket, cacheKey))),
-            `--file ${quoteShellMeta(fullPath)}`,
-        ], {
-            target: populateCacheOptions.target,
-            configPath: populateCacheOptions.wranglerConfigPath,
-            // R2 does not support the environment flag and results in the following error:
-            // Incorrect type for the 'cacheExpiry' field on 'HttpMetadata': the provided value is not of type 'date'.
-            environment: undefined,
-            logging: "error",
-        });
-    }
-    logger.info(`Successfully populated cache with ${assets.length} assets`);
-}
 async function populateR2IncrementalCache(buildOpts, config, populateCacheOptions, envVars) {
     logger.info("\nPopulating R2 incremental cache...");
     const binding = config.r2_buckets.find(({ binding }) => binding === R2_CACHE_BINDING_NAME);
@@ -244,21 +118,28 @@ async function populateR2IncrementalCache(buildOpts, config, populateCacheOption
     }
     const prefix = envVars[R2_CACHE_PREFIX_ENV_NAME];
     const assets = getCacheAssets(buildOpts);
-    // Force sequential upload for local target
-    if (populateCacheOptions.target === "local") {
-        logger.info("Using sequential upload for local R2 (batch upload only works with remote R2)");
-        return await populateR2IncrementalCacheWithSequentialUpload(buildOpts, bucket, prefix, assets, populateCacheOptions);
-    }
-    try {
-        // Attempt batch upload first (using rclone) - only for remote target
-        return await populateR2IncrementalCacheWithBatchUpload(bucket, prefix, assets, envVars);
-    }
-    catch (error) {
-        logger.warn(`Batch upload failed: ${error instanceof Error ? error.message : error}`);
-        logger.info("Falling back to sequential uploads...");
-        // Sequential upload fallback (using Wrangler)
-        return await populateR2IncrementalCacheWithSequentialUpload(buildOpts, bucket, prefix, assets, populateCacheOptions);
-    }
+    const objectList = assets.map(({ fullPath, key, buildId, isFetch }) => ({
+        key: computeCacheKey(key, {
+            prefix,
+            buildId,
+            cacheType: isFetch ? "fetch" : "cache",
+        }),
+        file: fullPath,
+    }));
+    const tempDir = await fsp.mkdtemp(path.join(os.tmpdir(), "open-next-"));
+    const listFile = path.join(tempDir, `r2-bulk-list.json`);
+    fs.writeFileSync(listFile, JSON.stringify(objectList));
+    const concurrency = Math.max(1, populateCacheOptions.cacheChunkSize ?? 50);
+    runWrangler(buildOpts, ["r2 bulk put", bucket, `--filename ${quoteShellMeta(listFile)}`, `--concurrency ${concurrency}`], {
+        target: populateCacheOptions.target,
+        configPath: populateCacheOptions.wranglerConfigPath,
+        // R2 does not support the environment flag and results in the following error:
+        // Incorrect type for the 'cacheExpiry' field on 'HttpMetadata': the provided value is not of type 'date'.
+        environment: undefined,
+        logging: "error",
+    });
+    fs.rmSync(listFile, { force: true });
+    logger.info(`Successfully populated cache with ${assets.length} assets`);
 }
 async function populateKVIncrementalCache(buildOpts, config, populateCacheOptions, envVars) {
     logger.info("\nPopulating KV incremental cache...");
@@ -271,8 +152,9 @@ async function populateKVIncrementalCache(buildOpts, config, populateCacheOption
     const chunkSize = Math.max(1, populateCacheOptions.cacheChunkSize ?? 25);
     const totalChunks = Math.ceil(assets.length / chunkSize);
     logger.info(`Inserting ${assets.length} assets to KV in chunks of ${chunkSize}`);
+    const tempDir = await fsp.mkdtemp(path.join(os.tmpdir(), "open-next-"));
     for (const i of tqdm(Array.from({ length: totalChunks }, (_, i) => i))) {
-        const chunkPath = path.join(buildOpts.outputDir, "cloudflare", `cache-chunk-${i}.json`);
+        const chunkPath = path.join(tempDir, `cache-chunk-${i}.json`);
         const kvMapping = assets
             .slice(i * chunkSize, (i + 1) * chunkSize)
             .map(({ fullPath, key, buildId, isFetch }) => ({
@@ -281,9 +163,9 @@ async function populateKVIncrementalCache(buildOpts, config, populateCacheOption
                 buildId,
                 cacheType: isFetch ? "fetch" : "cache",
             }),
-            value: readFileSync(fullPath, "utf8"),
+            value: fs.readFileSync(fullPath, "utf8"),
         }));
-        writeFileSync(chunkPath, JSON.stringify(kvMapping));
+        fs.writeFileSync(chunkPath, JSON.stringify(kvMapping));
         runWrangler(buildOpts, [
             "kv bulk put",
             quoteShellMeta(chunkPath),
@@ -295,7 +177,7 @@ async function populateKVIncrementalCache(buildOpts, config, populateCacheOption
             configPath: populateCacheOptions.wranglerConfigPath,
             logging: "error",
         });
-        rmSync(chunkPath);
+        fs.rmSync(chunkPath, { force: true });
     }
     logger.info(`Successfully populated cache with ${assets.length} assets`);
 }
@@ -320,7 +202,7 @@ function populateD1TagCache(buildOpts, config, populateCacheOptions) {
 }
 function populateStaticAssetsIncrementalCache(options) {
     logger.info("\nPopulating Workers static assets...");
-    cpSync(path.join(options.outputDir, "cache"), path.join(options.outputDir, "assets", STATIC_ASSETS_CACHE_DIR), { recursive: true });
+    fs.cpSync(path.join(options.outputDir, "cache"), path.join(options.outputDir, "assets", STATIC_ASSETS_CACHE_DIR), { recursive: true });
     logger.info(`Successfully populated static assets cache`);
 }
 /**

package/dist/cli/commands/utils.d.ts

@@ -65,7 +65,7 @@ export declare function getNormalizedOptions(config: OpenNextConfig, buildDir?:
  * @param args Wrangler environment and config path.
  * @returns Wrangler config.
  */
-export declare function readWranglerConfig(args: WithWranglerArgs): import("wrangler").Unstable_Config;
+export declare function readWranglerConfig(args: WithWranglerArgs): Config;
 /**
  * Adds flags for the wrangler config path and environment to the yargs configuration.
  */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opennextjs/cloudflare",
   "description": "Cloudflare builder for next apps",
-  "version": "1.11.1",
+  "version": "1.13.0",
   "type": "module",
   "bin": {
     "opennextjs-cloudflare": "dist/cli/index.js"
@@ -42,13 +42,12 @@
   },
   "homepage": "https://github.com/opennextjs/opennextjs-cloudflare",
   "dependencies": {
+    "@ast-grep/napi": "0.40.0",
     "@dotenvx/dotenvx": "1.31.0",
-    "@opennextjs/aws": "3.8.5",
-    "@types/rclone.js": "^0.6.3",
+    "@opennextjs/aws": "3.9.0",
     "cloudflare": "^4.4.1",
     "enquirer": "^2.4.1",
-    "glob": "^11.0.0",
-    "rclone.js": "^0.6.6",
+    "glob": "^12.0.0",
     "ts-tqdm": "^0.8.6",
     "yargs": "^18.0.0"
   },
@@ -61,7 +60,7 @@
     "@types/picomatch": "^4.0.0",
     "@types/yargs": "^17.0.33",
     "diff": "^8.0.2",
-    "esbuild": "^0.25.4",
+    "esbuild": "^0.27.0",
     "eslint": "^9.31.0",
     "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-simple-import-sort": "^12.1.1",
@@ -71,12 +70,12 @@
     "next": "~14.2.24",
     "picomatch": "^4.0.2",
     "rimraf": "^6.0.1",
-    "typescript": "^5.7.3",
+    "typescript": "^5.9.3",
     "typescript-eslint": "^8.37.0",
     "vitest": "^2.1.1"
   },
   "peerDependencies": {
-    "wrangler": "^4.38.0"
+    "wrangler": "^4.49.0"
   },
   "scripts": {
     "clean": "rimraf dist",