@opennextjs/cloudflare 1.0.0-beta.1 → 1.0.0-beta.3

package/dist/api/overrides/tag-cache/do-sharded-tag-cache.js

@@ -1,7 +1,8 @@
-import { debug, error } from "@opennextjs/aws/adapters/logger.js";
+import { error } from "@opennextjs/aws/adapters/logger.js";
 import { generateShardId } from "@opennextjs/aws/core/routing/queue.js";
 import { IgnorableError } from "@opennextjs/aws/utils/error.js";
 import { getCloudflareContext } from "../../cloudflare-context";
+import { debugCache } from "../internal";
 export const DEFAULT_WRITE_RETRIES = 3;
 export const DEFAULT_NUM_SHARDS = 4;
 export const NAME = "do-sharded-tag-cache";
@@ -102,7 +103,7 @@ class ShardedDOTagCache {
         const cfEnv = getCloudflareContext().env;
         const db = cfEnv.NEXT_TAG_CACHE_DO_SHARDED;
         if (!db)
-            debug("No Durable object found");
+            debugCache("No Durable object found");
         const isDisabled = !!globalThis.openNextConfig
             .dangerous?.disableTagCache;
         return !db || isDisabled
@@ -234,7 +235,7 @@ class ShardedDOTagCache {
             await cache.delete(key);
         }
         catch (e) {
-            debug("Error while deleting from regional cache", e);
+            debugCache("Error while deleting from regional cache", e);
         }
     }
 }

package/dist/cli/args.d.ts

@@ -5,7 +5,7 @@ export type Arguments = ({
     skipWranglerConfigCheck: boolean;
     minify: boolean;
 } | {
-    command: "preview" | "deploy";
+    command: "preview" | "deploy" | "upload";
     passthroughArgs: string[];
 } | {
     command: "populateCache";

package/dist/cli/args.js

@@ -28,6 +28,7 @@ export function getArgs() {
             };
         case "preview":
         case "deploy":
+        case "upload":
             return {
                 command: positionals[0],
                 outputDir,
@@ -44,7 +45,7 @@ export function getArgs() {
                 environment: getWranglerEnvironmentFlag(passthroughArgs),
             };
         default:
-            throw new Error("Error: invalid command, expected 'build' | 'preview' | 'deploy' | 'populateCache'");
+            throw new Error("Error: invalid command, expected 'build' | 'preview' | 'deploy' | 'upload' | 'populateCache'");
     }
 }
 function getPassthroughArgs() {

package/dist/cli/build/build.js

@@ -8,8 +8,8 @@ import logger from "@opennextjs/aws/logger.js";
 import { bundleServer } from "./bundle-server.js";
 import { compileCacheAssetsManifestSqlFile } from "./open-next/compile-cache-assets-manifest.js";
 import { compileEnvFiles } from "./open-next/compile-env-files.js";
+import { compileInit } from "./open-next/compile-init.js";
 import { compileDurableObjects } from "./open-next/compileDurableObjects.js";
-import { copyCacheAssets } from "./open-next/copyCacheAssets.js";
 import { createServerBundle } from "./open-next/createServerBundle.js";
 import { createWranglerConfigIfNotExistent } from "./utils/index.js";
 import { getVersion } from "./utils/version.js";
@@ -50,12 +50,13 @@ export async function build(options, config, projectOpts) {
     compileCache(options);
     // Compile .env files
     compileEnvFiles(options);
+    // Compile workerd init
+    compileInit(options);
     // Compile middleware
     await createMiddleware(options, { forceOnlyBuildOnce: true });
-    createStaticAssets(options);
+    createStaticAssets(options, { useBasePath: true });
     if (config.dangerous?.disableIncrementalCache !== true) {
         const { useTagCache, metaFiles } = createCacheAssets(options);
-        copyCacheAssets(options);
         if (useTagCache) {
             compileCacheAssetsManifestSqlFile(options, metaFiles);
         }

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

@@ -14,7 +14,6 @@ import { inlineEvalManifest } from "./patches/plugins/eval-manifest.js";
 import { inlineFindDir } from "./patches/plugins/find-dir.js";
 import { patchInstrumentation } from "./patches/plugins/instrumentation.js";
 import { inlineLoadManifest } from "./patches/plugins/load-manifest.js";
-import { patchNextMinimal } from "./patches/plugins/next-minimal.js";
 import { handleOptionalDependencies } from "./patches/plugins/optional-deps.js";
 import { patchDepdDeprecations } from "./patches/plugins/patch-depd-deprecations.js";
 import { fixRequire } from "./patches/plugins/require.js";
@@ -83,7 +82,6 @@ export async function bundleServer(buildOpts) {
             inlineLoadManifest(updater, buildOpts),
             inlineBuildId(updater),
             patchDepdDeprecations(updater),
-            patchNextMinimal(updater),
             // Apply updater updates, must be the last plugin
             updater.plugin,
         ],
@@ -125,46 +123,6 @@ export async function bundleServer(buildOpts) {
             "process.env.__NEXT_EXPERIMENTAL_REACT": `${needsExperimentalReact(nextConfig)}`,
         },
         platform: "node",
-        banner: {
-            js: `
-// Used by unbundled js files (which don't inherit the __dirname present in the define field)
-// so we also need to set it on the global scope
-// Note: this was hit in the next/dist/compiled/@opentelemetry/api module
-globalThis.__dirname ??= "";
-globalThis.__filename ??= "";
-
-// Do not crash on cache not supported
-// https://github.com/cloudflare/workerd/pull/2434
-// compatibility flag "cache_option_enabled" -> does not support "force-cache"
-const curFetch = globalThis.fetch;
-globalThis.fetch = (input, init) => {
-  if (init) {
-    delete init.cache;
-  }
-  return curFetch(input, init);
-};
-import __cf_stream from 'node:stream';
-fetch = globalThis.fetch;
-const CustomRequest = class extends globalThis.Request {
-  constructor(input, init) {
-    if (init) {
-      delete init.cache;
-      // https://github.com/cloudflare/workerd/issues/2746
-      // https://github.com/cloudflare/workerd/issues/3245
-      Object.defineProperty(init, "body", {
-        value: init.body instanceof __cf_stream.Readable ? ReadableStream.from(init.body) : init.body
-      });
-    }
-    super(input, init);
-  }
-};
-globalThis.Request = CustomRequest;
-Request = globalThis.Request;
-// Makes the edge converter returns either a Response or a Request.
-globalThis.__dangerous_ON_edge_converter_returns_request = true;
-globalThis.__BUILD_TIMESTAMP_MS__ = ${Date.now()};
-`,
-        },
     });
     fs.writeFileSync(openNextServerBundle + ".meta.json", JSON.stringify(result.metafile, null, 2));
     await updateWorkerBundledCode(openNextServerBundle, buildOpts);
@@ -185,6 +143,7 @@ export async function updateWorkerBundledCode(workerOutputFile, buildOpts) {
         [
             "'require(this.middlewareManifestPath)'",
             (code) => patches.inlineMiddlewareManifestRequire(code, buildOpts),
+            { isOptional: true },
         ],
         [
             "`require.resolve` call",

package/dist/cli/build/open-next/compile-env-files.js

@@ -5,7 +5,7 @@ import { extractProjectEnvVars } from "../utils/index.js";
  * Compiles the values extracted from the project's env files to the output directory for use in the worker.
  */
 export function compileEnvFiles(buildOpts) {
-    const envDir = path.join(buildOpts.outputDir, "env");
+    const envDir = path.join(buildOpts.outputDir, "cloudflare");
     fs.mkdirSync(envDir, { recursive: true });
     ["production", "development", "test"].forEach((mode) => fs.appendFileSync(path.join(envDir, `next-env.mjs`), `export const ${mode} = ${JSON.stringify(extractProjectEnvVars(mode, buildOpts))};\n`));
 }

package/dist/cli/build/open-next/compile-init.d.ts

@@ -0,0 +1,5 @@
+import type { BuildOptions } from "@opennextjs/aws/build/helper.js";
+/**
+ * Compiles the initialization code for the workerd runtime
+ */
+export declare function compileInit(options: BuildOptions): Promise<void>;

package/dist/cli/build/open-next/compile-init.js

@@ -0,0 +1,27 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadConfig } from "@opennextjs/aws/adapters/config/util.js";
+import { build } from "esbuild";
+/**
+ * Compiles the initialization code for the workerd runtime
+ */
+export async function compileInit(options) {
+    const currentDir = path.join(path.dirname(fileURLToPath(import.meta.url)));
+    const templatesDir = path.join(currentDir, "../../templates");
+    const initPath = path.join(templatesDir, "init.js");
+    const nextConfig = loadConfig(path.join(options.appBuildOutputPath, ".next"));
+    const basePath = nextConfig.basePath ?? "";
+    await build({
+        entryPoints: [initPath],
+        outdir: path.join(options.outputDir, "cloudflare"),
+        bundle: false,
+        minify: false,
+        format: "esm",
+        target: "esnext",
+        platform: "node",
+        define: {
+            __BUILD_TIMESTAMP_MS__: JSON.stringify(Date.now()),
+            __NEXT_BASE_PATH__: JSON.stringify(basePath),
+        },
+    });
+}

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

@@ -10,8 +10,9 @@ import { copyMiddlewareResources, generateEdgeBundle } from "@opennextjs/aws/bui
 import * as buildHelper from "@opennextjs/aws/build/helper.js";
 import { installDependencies } from "@opennextjs/aws/build/installDeps.js";
 import { applyCodePatches } from "@opennextjs/aws/build/patch/codePatcher.js";
-import { patchFetchCacheForISR, patchUnstableCacheForISR, } from "@opennextjs/aws/build/patch/patchFetchCacheISR.js";
-import { patchFetchCacheSetMissingWaitUntil } from "@opennextjs/aws/build/patch/patchFetchCacheWaitUntil.js";
+import { patchEnvVars, patchFetchCacheForISR, patchFetchCacheSetMissingWaitUntil, patchNextServer, patchUnstableCacheForISR, } from "@opennextjs/aws/build/patch/patches/index.js";
+// TODO: import from patches/index.js when https://github.com/opennextjs/opennextjs-aws/pull/827 is released
+import { patchBackgroundRevalidation } from "@opennextjs/aws/build/patch/patches/patchBackgroundRevalidation.js";
 import logger from "@opennextjs/aws/logger.js";
 import { minifyAll } from "@opennextjs/aws/minimize-js.js";
 import { openNextEdgePlugins } from "@opennextjs/aws/plugins/edge.js";
@@ -124,6 +125,9 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
         patchFetchCacheSetMissingWaitUntil,
         patchFetchCacheForISR,
         patchUnstableCacheForISR,
+        patchNextServer,
+        patchEnvVars,
+        patchBackgroundRevalidation,
         // Cloudflare specific patches
         patchResRevalidate,
         ...additionalCodePatches,
@@ -147,6 +151,7 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
                 ...(disableNextPrebundledReact ? ["applyNextjsPrebundledReact"] : []),
                 ...(disableRouting ? ["withRouting"] : []),
                 ...(isAfter142 ? ["patchAsyncStorage"] : []),
+                ...(isAfter141 ? ["appendPrefetch"] : []),
             ],
         }),
         openNextReplacementPlugin({

package/dist/cli/build/utils/ensure-cf-config.js

@@ -17,6 +17,7 @@ export function ensureCloudflareConfig(config) {
             config.default?.override?.queue === "direct" ||
             typeof config.default?.override?.queue === "function",
         mwIsMiddlewareIntegrated: config.middleware === undefined,
+        hasCryptoExternal: config.edgeExternals?.includes("node:crypto"),
     };
     if (config.default?.override?.queue === "direct") {
         logger.warn("The direct mode queue is not recommended for use in production.");
@@ -34,6 +35,7 @@ export function ensureCloudflareConfig(config) {
               queue: "dummy" | "direct" | function,
             },
           },
+          edgeExternals: ["node:crypto"],
         }\n\n`.replace(/^ {8}/gm, ""));
     }
 }

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

@@ -1,6 +1,13 @@
 import type { BuildOptions } from "@opennextjs/aws/build/helper.js";
 import type { OpenNextConfig } from "@opennextjs/aws/types/open-next.js";
 import type { WranglerTarget } from "../utils/run-wrangler.js";
+export type CacheAsset = {
+    isFetch: boolean;
+    fullPath: string;
+    key: string;
+    buildId: string;
+};
+export declare function getCacheAssets(opts: BuildOptions): CacheAsset[];
 export declare function populateCache(options: BuildOptions, config: OpenNextConfig, populateCacheOptions: {
     target: WranglerTarget;
     environment?: string;

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

@@ -1,30 +1,118 @@
-import { existsSync } from "node:fs";
+import { cpSync, existsSync } from "node:fs";
 import path from "node:path";
 import logger from "@opennextjs/aws/logger.js";
 import { globSync } from "glob";
 import { tqdm } from "ts-tqdm";
 import { unstable_readConfig } from "wrangler";
-import { NAME as R2_CACHE_NAME } from "../../api/overrides/incremental-cache/r2-incremental-cache.js";
-import { NAME as D1_TAG_NAME } from "../../api/overrides/tag-cache/d1-next-tag-cache.js";
+import { BINDING_NAME as KV_CACHE_BINDING_NAME, computeCacheKey as computeKVCacheKey, NAME as KV_CACHE_NAME, } from "../../api/overrides/incremental-cache/kv-incremental-cache.js";
+import { BINDING_NAME as R2_CACHE_BINDING_NAME, computeCacheKey as computeR2CacheKey, NAME as R2_CACHE_NAME, PREFIX_ENV_NAME as R2_CACHE_PREFIX_ENV_NAME, } from "../../api/overrides/incremental-cache/r2-incremental-cache.js";
+import { CACHE_DIR as STATIC_ASSETS_CACHE_DIR, NAME as STATIC_ASSETS_CACHE_NAME, } from "../../api/overrides/incremental-cache/static-assets-incremental-cache.js";
+import { BINDING_NAME as D1_TAG_BINDING_NAME, NAME as D1_TAG_NAME, } from "../../api/overrides/tag-cache/d1-next-tag-cache.js";
 import { runWrangler } from "../utils/run-wrangler.js";
 async function resolveCacheName(value) {
     return typeof value === "function" ? (await value()).name : value;
 }
-function getCacheAssetPaths(opts) {
-    return globSync(path.join(opts.outputDir, "cache/**/*"), {
+export function getCacheAssets(opts) {
+    const allFiles = globSync(path.join(opts.outputDir, "cache/**/*"), {
         withFileTypes: true,
         windowsPathsNoEscape: true,
-    })
-        .filter((f) => f.isFile())
-        .map((f) => {
-        const relativePath = path.relative(path.join(opts.outputDir, "cache"), f.fullpathPosix());
-        return {
-            fsPath: f.fullpathPosix(),
-            destPath: relativePath.startsWith("__fetch")
-                ? `${relativePath.replace("__fetch/", "")}.fetch`
-                : relativePath,
-        };
-    });
+    }).filter((f) => f.isFile());
+    const assets = [];
+    for (const file of allFiles) {
+        const fullPath = file.fullpathPosix();
+        const relativePath = path.relative(path.join(opts.outputDir, "cache"), fullPath);
+        if (relativePath.startsWith("__fetch")) {
+            const [__fetch, buildId, ...keyParts] = relativePath.split("/");
+            if (__fetch !== "__fetch" || buildId === undefined || keyParts.length === 0) {
+                throw new Error(`Invalid path for a Cache Asset file: ${relativePath}`);
+            }
+            assets.push({
+                isFetch: true,
+                fullPath,
+                key: `/${keyParts.join("/")}`,
+                buildId,
+            });
+        }
+        else {
+            const [buildId, ...keyParts] = relativePath.slice(0, -".cache".length).split("/");
+            if (!relativePath.endsWith(".cache") || buildId === undefined || keyParts.length === 0) {
+                throw new Error(`Invalid path for a Cache Asset file: ${relativePath}`);
+            }
+            assets.push({
+                isFetch: false,
+                fullPath,
+                key: `/${keyParts.join("/")}`,
+                buildId,
+            });
+        }
+    }
+    return assets;
+}
+function populateR2IncrementalCache(options, populateCacheOptions) {
+    logger.info("\nPopulating R2 incremental cache...");
+    const config = unstable_readConfig({ env: populateCacheOptions.environment });
+    const binding = config.r2_buckets.find(({ binding }) => binding === R2_CACHE_BINDING_NAME);
+    if (!binding) {
+        throw new Error(`No R2 binding ${JSON.stringify(R2_CACHE_BINDING_NAME)} found!`);
+    }
+    const bucket = binding.bucket_name;
+    if (!bucket) {
+        throw new Error(`R2 binding ${JSON.stringify(R2_CACHE_BINDING_NAME)} should have a 'bucket_name'`);
+    }
+    const assets = getCacheAssets(options);
+    for (const { fullPath, key, buildId, isFetch } of tqdm(assets)) {
+        const cacheKey = computeR2CacheKey(key, {
+            directory: process.env[R2_CACHE_PREFIX_ENV_NAME],
+            buildId,
+            isFetch,
+        });
+        runWrangler(options, ["r2 object put", JSON.stringify(path.join(bucket, cacheKey)), `--file ${JSON.stringify(fullPath)}`], 
+        // NOTE: 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'.
+        { target: populateCacheOptions.target, excludeRemoteFlag: true, logging: "error" });
+    }
+    logger.info(`Successfully populated cache with ${assets.length} assets`);
+}
+function populateKVIncrementalCache(options, populateCacheOptions) {
+    logger.info("\nPopulating KV incremental cache...");
+    const config = unstable_readConfig({ env: populateCacheOptions.environment });
+    const binding = config.kv_namespaces.find(({ binding }) => binding === KV_CACHE_BINDING_NAME);
+    if (!binding) {
+        throw new Error(`No KV binding ${JSON.stringify(KV_CACHE_BINDING_NAME)} found!`);
+    }
+    const assets = getCacheAssets(options);
+    for (const { fullPath, key, buildId, isFetch } of tqdm(assets)) {
+        const cacheKey = computeKVCacheKey(key, {
+            buildId,
+            isFetch,
+        });
+        runWrangler(options, [
+            "kv key put",
+            JSON.stringify(cacheKey),
+            `--binding ${JSON.stringify(KV_CACHE_BINDING_NAME)}`,
+            `--path ${JSON.stringify(fullPath)}`,
+        ], { ...populateCacheOptions, logging: "error" });
+    }
+    logger.info(`Successfully populated cache with ${assets.length} assets`);
+}
+function populateD1TagCache(options, populateCacheOptions) {
+    logger.info("\nCreating D1 table if necessary...");
+    const config = unstable_readConfig({ env: populateCacheOptions.environment });
+    const binding = config.d1_databases.find(({ binding }) => binding === D1_TAG_BINDING_NAME);
+    if (!binding) {
+        throw new Error(`No D1 binding ${JSON.stringify(D1_TAG_BINDING_NAME)} found!`);
+    }
+    runWrangler(options, [
+        "d1 execute",
+        JSON.stringify(D1_TAG_BINDING_NAME),
+        `--command "CREATE TABLE IF NOT EXISTS revalidations (tag TEXT NOT NULL, revalidatedAt INTEGER NOT NULL, UNIQUE(tag) ON CONFLICT REPLACE);"`,
+    ], { ...populateCacheOptions, logging: "error" });
+    logger.info("\nSuccessfully created D1 table");
+}
+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 });
+    logger.info(`Successfully populated static assets cache`);
 }
 export async function populateCache(options, config, populateCacheOptions) {
     const { incrementalCache, tagCache } = config.default.override ?? {};
@@ -35,28 +123,15 @@ export async function populateCache(options, config, populateCacheOptions) {
     if (!config.dangerous?.disableIncrementalCache && incrementalCache) {
         const name = await resolveCacheName(incrementalCache);
         switch (name) {
-            case R2_CACHE_NAME: {
-                const config = unstable_readConfig({ env: populateCacheOptions.environment });
-                const binding = (config.r2_buckets ?? []).find(({ binding }) => binding === "NEXT_INC_CACHE_R2_BUCKET");
-                if (!binding) {
-                    throw new Error("No R2 binding 'NEXT_INC_CACHE_R2_BUCKET' found!");
-                }
-                const bucket = binding.bucket_name;
-                if (!bucket) {
-                    throw new Error("R2 binding 'NEXT_INC_CACHE_R2_BUCKET' should have a 'bucket_name'");
-                }
-                logger.info("\nPopulating R2 incremental cache...");
-                const assets = getCacheAssetPaths(options);
-                for (const { fsPath, destPath } of tqdm(assets)) {
-                    const fullDestPath = path.join(bucket, process.env.NEXT_INC_CACHE_R2_PREFIX ?? "incremental-cache", destPath);
-                    runWrangler(options, ["r2 object put", JSON.stringify(fullDestPath), `--file ${JSON.stringify(fsPath)}`], 
-                    // NOTE: 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'.
-                    { target: populateCacheOptions.target, excludeRemoteFlag: true, logging: "error" });
-                }
-                logger.info(`Successfully populated cache with ${assets.length} assets`);
+            case R2_CACHE_NAME:
+                populateR2IncrementalCache(options, populateCacheOptions);
+                break;
+            case KV_CACHE_NAME:
+                populateKVIncrementalCache(options, populateCacheOptions);
+                break;
+            case STATIC_ASSETS_CACHE_NAME:
+                populateStaticAssetsIncrementalCache(options);
                 break;
-            }
             default:
                 logger.info("Incremental cache does not need populating");
         }
@@ -64,16 +139,9 @@ export async function populateCache(options, config, populateCacheOptions) {
     if (!config.dangerous?.disableTagCache && !config.dangerous?.disableIncrementalCache && tagCache) {
         const name = await resolveCacheName(tagCache);
         switch (name) {
-            case D1_TAG_NAME: {
-                logger.info("\nCreating D1 table if necessary...");
-                runWrangler(options, [
-                    "d1 execute",
-                    "NEXT_TAG_CACHE_D1",
-                    `--command "CREATE TABLE IF NOT EXISTS revalidations (tag TEXT NOT NULL, revalidatedAt INTEGER NOT NULL, UNIQUE(tag) ON CONFLICT REPLACE);"`,
-                ], { ...populateCacheOptions, logging: "error" });
-                logger.info("\nSuccessfully created D1 table");
+            case D1_TAG_NAME:
+                populateD1TagCache(options, populateCacheOptions);
                 break;
-            }
             default:
                 logger.info("Tag cache does not need populating");
         }

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

@@ -0,0 +1,61 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import mockFs from "mock-fs";
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { getCacheAssets } from "./populate-cache";
+describe("getCacheAssets", () => {
+    beforeAll(() => {
+        mockFs();
+        const fetchBaseDir = "/base/path/cache/__fetch/buildID";
+        const cacheDir = "/base/path/cache/buildID/path/to";
+        mkdirSync(fetchBaseDir, { recursive: true });
+        mkdirSync(cacheDir, { recursive: true });
+        for (let i = 0; i < 3; i++) {
+            writeFileSync(path.join(fetchBaseDir, `${i}`), "", { encoding: "utf-8" });
+            writeFileSync(path.join(cacheDir, `${i}.cache`), "", { encoding: "utf-8" });
+        }
+    });
+    afterAll(() => mockFs.restore());
+    test("list cache assets", () => {
+        expect(getCacheAssets({ outputDir: "/base/path" })).toMatchInlineSnapshot(`
+      [
+        {
+          "buildId": "buildID",
+          "fullPath": "/base/path/cache/buildID/path/to/2.cache",
+          "isFetch": false,
+          "key": "/path/to/2",
+        },
+        {
+          "buildId": "buildID",
+          "fullPath": "/base/path/cache/buildID/path/to/1.cache",
+          "isFetch": false,
+          "key": "/path/to/1",
+        },
+        {
+          "buildId": "buildID",
+          "fullPath": "/base/path/cache/buildID/path/to/0.cache",
+          "isFetch": false,
+          "key": "/path/to/0",
+        },
+        {
+          "buildId": "buildID",
+          "fullPath": "/base/path/cache/__fetch/buildID/2",
+          "isFetch": true,
+          "key": "/2",
+        },
+        {
+          "buildId": "buildID",
+          "fullPath": "/base/path/cache/__fetch/buildID/1",
+          "isFetch": true,
+          "key": "/1",
+        },
+        {
+          "buildId": "buildID",
+          "fullPath": "/base/path/cache/__fetch/buildID/0",
+          "isFetch": true,
+          "key": "/0",
+        },
+      ]
+    `);
+    });
+});

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

@@ -0,0 +1,5 @@
+import { BuildOptions } from "@opennextjs/aws/build/helper.js";
+import { OpenNextConfig } from "@opennextjs/aws/types/open-next.js";
+export declare function upload(options: BuildOptions, config: OpenNextConfig, uploadOptions: {
+    passthroughArgs: string[];
+}): Promise<void>;

package/dist/cli/commands/upload.js

@@ -0,0 +1,9 @@
+import { getWranglerEnvironmentFlag, runWrangler } from "../utils/run-wrangler.js";
+import { populateCache } from "./populate-cache.js";
+export async function upload(options, config, uploadOptions) {
+    await populateCache(options, config, {
+        target: "remote",
+        environment: getWranglerEnvironmentFlag(uploadOptions.passthroughArgs),
+    });
+    runWrangler(options, ["versions upload", ...uploadOptions.passthroughArgs], { logging: "all" });
+}

package/dist/cli/index.js

@@ -11,6 +11,7 @@ import { createOpenNextConfigIfNotExistent, ensureCloudflareConfig } from "./bui
 import { deploy } from "./commands/deploy.js";
 import { populateCache } from "./commands/populate-cache.js";
 import { preview } from "./commands/preview.js";
+import { upload } from "./commands/upload.js";
 const nextAppDir = process.cwd();
 async function runCommand(args) {
     printHeader(`Cloudflare ${args.command}`);
@@ -33,6 +34,8 @@ async function runCommand(args) {
             return preview(options, config, args);
         case "deploy":
             return deploy(options, config, args);
+        case "upload":
+            return upload(options, config, args);
         case "populateCache":
             return populateCache(options, config, args);
     }

package/dist/cli/templates/init.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Initialization for the workerd runtime.
+ *
+ * The file must be imported at the top level the worker.
+ */
+/**
+ * Executes the handler with the Cloudflare context.
+ */
+export declare function runWithCloudflareRequestContext(request: Request, env: CloudflareEnv, ctx: ExecutionContext, handler: () => Promise<Response>): Promise<Response>;
+declare global {
+    var __BUILD_TIMESTAMP_MS__: number;
+    var __NEXT_BASE_PATH__: string;
+}