@opennextjs/cloudflare 0.2.0 → 0.3.0

package/README.md

@@ -2,9 +2,9 @@
 
 Deploy Next.js apps to Cloudflare!
 
-[OpenNext for Cloudflare](https://opennext.js.org/cloudflare) is Cloudflare specific adapter that enables deployment of Next.js applications to Cloudflare.
+[OpenNext for Cloudflare](https://opennext.js.org/cloudflare) is a Cloudflare specific adapter that enables deployment of Next.js applications to Cloudflare.
 
-## Getting started
+## Get started
 
 You can use [`create-next-app`](https://nextjs.org/docs/pages/api-reference/cli/create-next-app) to start a new application or take an existing Next.js application and deploy it to Cloudflare using the following few steps:
 
@@ -16,9 +16,9 @@ You can use [`create-next-app`](https://nextjs.org/docs/pages/api-reference/cli/
   npm add -D wrangler@latest @opennextjs/cloudflare
   # or
   pnpm add -D wrangler@latest @opennextjs/cloudflare
-  # or
+  # or
   yarn add -D wrangler@latest @opennextjs/cloudflare
-  # or
+  # or
   bun add -D wrangler@latest @opennextjs/cloudflare
   ```
 
@@ -27,39 +27,49 @@ You can use [`create-next-app`](https://nextjs.org/docs/pages/api-reference/cli/
   ```toml
   #:schema node_modules/wrangler/config-schema.json
   name = "<your-app-name>"
-  main = ".worker-next/index.mjs"
+  main = ".open-next/worker.js"
 
   compatibility_date = "2024-09-23"
   compatibility_flags = ["nodejs_compat"]
 
   # Use the new Workers + Assets to host the static frontend files
-  assets = { directory = ".worker-next/assets", binding = "ASSETS" }
-  ```
-
-You can enable Incremental Static Regeneration ([ISR](https://nextjs.org/docs/app/building-your-application/data-fetching/incremental-static-regeneration)) by adding a KV binding named `NEXT_CACHE_WORKERS_KV` to your `wrangler.toml`:
-
-- Create the binding
-
-  ```bash
-  npx wrangler kv namespace create NEXT_CACHE_WORKERS_KV
-  # or
-  pnpm wrangler kv namespace create NEXT_CACHE_WORKERS_KV
-  # or
-  yarn wrangler kv namespace create NEXT_CACHE_WORKERS_KV
-  # or
-  bun wrangler kv namespace create NEXT_CACHE_WORKERS_KV
-  ```
-
-- Paste the snippet to your `wrangler.toml`:
-
-  ```bash
-  [[kv_namespaces]]
-  binding = "NEXT_CACHE_WORKERS_KV"
-  id = "..."
+  assets = { directory = ".open-next/assets", binding = "ASSETS" }
   ```
 
-> [!WARNING]
-> The current support for ISR is limited.
+- add a `open-next.config.ts` at the root of your project:
+
+```ts
+import type { OpenNextConfig } from "open-next/types/open-next";
+
+const config: OpenNextConfig = {
+  default: {
+    override: {
+      wrapper: "cloudflare-node",
+      converter: "edge",
+      // Unused implementation
+      incrementalCache: "dummy",
+      tagCache: "dummy",
+      queue: "dummy",
+    },
+  },
+
+  middleware: {
+    external: true,
+    override: {
+      wrapper: "cloudflare-edge",
+      converter: "edge",
+      proxyExternalRequest: "fetch",
+    },
+  },
+};
+
+export default config;
+```
+
+## Known issues
+
+- `▲ [WARNING] Suspicious assignment to defined constant "process.env.NODE_ENV" [assign-to-define]` can safely be ignored
+- Maybe more, still experimental...
 
 ## Local development
 
@@ -72,13 +82,13 @@ Run the following commands to preview the production build of your application l
 - build the app and adapt it for Cloudflare
 
   ```bash
-  npx cloudflare
+  npx opennextjs-cloudflare
   # or
-  pnpm cloudflare
+  pnpm opennextjs-cloudflare
   # or
-  yarn cloudflare
+  yarn opennextjs-cloudflare
   # or
-  bun cloudflare
+  bun opennextjs-cloudflare
   ```
 
 - Preview the app in Wrangler
@@ -100,11 +110,11 @@ Deploy your application to production with the following:
 - build the app and adapt it for Cloudflare
 
   ```bash
-  npx cloudflare && npx wrangler deploy
+  npx opennextjs-cloudflare && npx wrangler deploy
   # or
-  pnpm cloudflare && pnpm wrangler deploy
+  pnpm opennextjs-cloudflare && pnpm wrangler deploy
   # or
-  yarn cloudflare && yarn wrangler deploy
+  yarn opennextjs-cloudflare && yarn wrangler deploy
   # or
-  bun cloudflare && bun wrangler deploy
+  bun opennextjs-cloudflare && bun wrangler deploy
   ```

package/dist/api/{get-cloudflare-context.d.mts → get-cloudflare-context.d.ts}

@@ -1,8 +1,10 @@
 declare global {
     interface CloudflareEnv {
+        NEXT_CACHE_WORKERS_KV?: KVNamespace;
+        ASSETS?: Fetcher;
     }
 }
-type CloudflareContext<CfProperties extends Record<string, unknown> = IncomingRequestCfProperties, Context = ExecutionContext> = {
+export type CloudflareContext<CfProperties extends Record<string, unknown> = IncomingRequestCfProperties, Context = ExecutionContext> = {
     /**
      * the worker's [bindings](https://developers.cloudflare.com/workers/runtime-apis/bindings/)
      */
@@ -21,6 +23,4 @@ type CloudflareContext<CfProperties extends Record<string, unknown> = IncomingRe
  *
  * @returns the cloudflare context
  */
-declare function getCloudflareContext<CfProperties extends Record<string, unknown> = IncomingRequestCfProperties, Context = ExecutionContext>(): Promise<CloudflareContext<CfProperties, Context>>;
-
-export { type CloudflareContext, getCloudflareContext };
+export declare function getCloudflareContext<CfProperties extends Record<string, unknown> = IncomingRequestCfProperties, Context = ExecutionContext>(): Promise<CloudflareContext<CfProperties, Context>>;

package/dist/api/get-cloudflare-context.js

@@ -0,0 +1,39 @@
+// Note: this symbol needs to be kept in sync with the one used in `src/cli/templates/worker.ts`
+const cloudflareContextSymbol = Symbol.for("__cloudflare-context__");
+/**
+ * Utility to get the current Cloudflare context
+ *
+ * @returns the cloudflare context
+ */
+export async function getCloudflareContext() {
+    const global = globalThis;
+    const cloudflareContext = global[cloudflareContextSymbol];
+    if (!cloudflareContext) {
+        // the cloudflare context is initialized by the worker and is always present in production/preview,
+        // so, it not being present means that the application is running under `next dev`
+        return getCloudflareContextInNextDev();
+    }
+    return cloudflareContext;
+}
+const cloudflareContextInNextDevSymbol = Symbol.for("__next-dev/cloudflare-context__");
+/**
+ * Gets a local proxy version of the cloudflare context (created using `getPlatformProxy`) when
+ * running in the standard next dev server (via `next dev`)
+ *
+ * @returns the local proxy version of the cloudflare context
+ */
+async function getCloudflareContextInNextDev() {
+    const global = globalThis;
+    if (!global[cloudflareContextInNextDevSymbol]) {
+        // Note: we never want wrangler to be bundled in the Next.js app, that's why the import below looks like it does
+        const { getPlatformProxy } = await import(
+        /* webpackIgnore: true */ `${"__wrangler".replaceAll("_", "")}`);
+        const { env, cf, ctx } = await getPlatformProxy();
+        global[cloudflareContextInNextDevSymbol] = {
+            env,
+            cf: cf,
+            ctx: ctx,
+        };
+    }
+    return global[cloudflareContextInNextDevSymbol];
+}

package/dist/api/index.d.ts

@@ -0,0 +1 @@
+export * from "./get-cloudflare-context.js";

package/dist/api/index.js

@@ -0,0 +1 @@
+export * from "./get-cloudflare-context.js";

package/dist/api/kvCache.d.ts

@@ -0,0 +1,27 @@
+import type { KVNamespace } from "@cloudflare/workers-types";
+import type { CacheValue, IncrementalCache, WithLastModified } from "@opennextjs/aws/types/overrides";
+export declare const CACHE_ASSET_DIR = "cnd-cgi/_next_cache";
+export declare const STATUS_DELETED = 1;
+/**
+ * Open Next cache based on cloudflare KV and Assets.
+ *
+ * Note: The class is instantiated outside of the request context.
+ * The cloudflare context and process.env are not initialzed yet
+ * when the constructor is called.
+ */
+declare class Cache implements IncrementalCache {
+    readonly name = "cloudflare-kv";
+    protected initialized: boolean;
+    protected kv: KVNamespace | undefined;
+    protected assets: Fetcher | undefined;
+    get<IsFetch extends boolean = false>(key: string, isFetch?: IsFetch): Promise<WithLastModified<CacheValue<IsFetch>>>;
+    set<IsFetch extends boolean = false>(key: string, value: CacheValue<IsFetch>, isFetch?: IsFetch): Promise<void>;
+    delete(key: string): Promise<void>;
+    protected getKVKey(key: string, isFetch?: boolean): string;
+    protected getAssetUrl(key: string, isFetch?: boolean): string;
+    protected debug(...args: unknown[]): void;
+    protected getBuildId(): string;
+    protected init(): Promise<void>;
+}
+declare const _default: Cache;
+export default _default;

package/dist/api/kvCache.js

@@ -0,0 +1,121 @@
+import { IgnorableError, RecoverableError } from "@opennextjs/aws/utils/error.js";
+import { getCloudflareContext } from "./get-cloudflare-context.js";
+export const CACHE_ASSET_DIR = "cnd-cgi/_next_cache";
+export const STATUS_DELETED = 1;
+/**
+ * Open Next cache based on cloudflare KV and Assets.
+ *
+ * Note: The class is instantiated outside of the request context.
+ * The cloudflare context and process.env are not initialzed yet
+ * when the constructor is called.
+ */
+class Cache {
+    name = "cloudflare-kv";
+    initialized = false;
+    kv;
+    assets;
+    async get(key, isFetch) {
+        if (!this.initialized) {
+            await this.init();
+        }
+        if (!(this.kv || this.assets)) {
+            throw new IgnorableError(`No KVNamespace nor Fetcher`);
+        }
+        this.debug(`Get ${key}`);
+        try {
+            let entry = null;
+            if (this.kv) {
+                this.debug(`- From KV`);
+                const kvKey = this.getKVKey(key, isFetch);
+                entry = await this.kv.get(kvKey, "json");
+                if (entry?.status === STATUS_DELETED) {
+                    return {};
+                }
+            }
+            if (!entry && this.assets) {
+                this.debug(`- From Assets`);
+                const url = this.getAssetUrl(key, isFetch);
+                const response = await this.assets.fetch(url);
+                if (response.ok) {
+                    // TODO: consider populating KV with the asset value if faster.
+                    // This could be optional as KV writes are $$.
+                    // See https://github.com/opennextjs/opennextjs-cloudflare/pull/194#discussion_r1893166026
+                    entry = {
+                        value: await response.json(),
+                        // __BUILD_TIMESTAMP_MS__ is injected by ESBuild.
+                        lastModified: globalThis.__BUILD_TIMESTAMP_MS__,
+                    };
+                }
+            }
+            this.debug(entry ? `-> hit` : `-> miss`);
+            return { value: entry?.value, lastModified: entry?.lastModified };
+        }
+        catch {
+            throw new RecoverableError(`Failed to get cache [${key}]`);
+        }
+    }
+    async set(key, value, isFetch) {
+        if (!this.initialized) {
+            await this.init();
+        }
+        if (!this.kv) {
+            throw new IgnorableError(`No KVNamespace`);
+        }
+        this.debug(`Set ${key}`);
+        try {
+            const kvKey = this.getKVKey(key, isFetch);
+            // Note: We can not set a TTL as we might fallback to assets,
+            //       still removing old data (old BUILD_ID) could help avoiding
+            //       the cache growing too big.
+            await this.kv.put(kvKey, JSON.stringify({
+                value,
+                // Note: `Date.now()` returns the time of the last IO rather than the actual time.
+                //       See https://developers.cloudflare.com/workers/reference/security-model/
+                lastModified: Date.now(),
+            }));
+        }
+        catch {
+            throw new RecoverableError(`Failed to set cache [${key}]`);
+        }
+    }
+    async delete(key) {
+        if (!this.initialized) {
+            await this.init();
+        }
+        if (!this.kv) {
+            throw new IgnorableError(`No KVNamespace`);
+        }
+        this.debug(`Delete ${key}`);
+        try {
+            const kvKey = this.getKVKey(key, /* isFetch= */ false);
+            // Do not delete the key as we would then fallback to the assets.
+            await this.kv.put(kvKey, JSON.stringify({ status: STATUS_DELETED }));
+        }
+        catch {
+            throw new RecoverableError(`Failed to delete cache [${key}]`);
+        }
+    }
+    getKVKey(key, isFetch) {
+        return `${this.getBuildId()}/${key}.${isFetch ? "fetch" : "cache"}`;
+    }
+    getAssetUrl(key, isFetch) {
+        return isFetch
+            ? `http://assets.local/${CACHE_ASSET_DIR}/__fetch/${this.getBuildId()}/${key}`
+            : `http://assets.local/${CACHE_ASSET_DIR}/${this.getBuildId()}/${key}.cache`;
+    }
+    debug(...args) {
+        if (process.env.NEXT_PRIVATE_DEBUG_CACHE) {
+            console.log(`[Cache ${this.name}] `, ...args);
+        }
+    }
+    getBuildId() {
+        return process.env.NEXT_BUILD_ID ?? "no-build-id";
+    }
+    async init() {
+        const env = (await getCloudflareContext()).env;
+        this.kv = env.NEXT_CACHE_WORKERS_KV;
+        this.assets = env.ASSETS;
+        this.initialized = true;
+    }
+}
+export default new Cache();

package/dist/cli/args.d.ts

@@ -0,0 +1,5 @@
+export declare function getArgs(): {
+    skipNextBuild: boolean;
+    outputDir?: string;
+    minify: boolean;
+};

package/dist/cli/args.js

@@ -0,0 +1,48 @@
+import { mkdirSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+import { parseArgs } from "node:util";
+export function getArgs() {
+    const { skipBuild, output, noMinify } = parseArgs({
+        options: {
+            skipBuild: {
+                type: "boolean",
+                short: "s",
+                default: false,
+            },
+            output: {
+                type: "string",
+                short: "o",
+            },
+            noMinify: {
+                type: "boolean",
+                default: false,
+            },
+        },
+        allowPositionals: false,
+    }).values;
+    const outputDir = output ? resolve(output) : undefined;
+    if (outputDir) {
+        assertDirArg(outputDir, "output", true);
+    }
+    return {
+        outputDir,
+        skipNextBuild: skipBuild || ["1", "true", "yes"].includes(String(process.env.SKIP_NEXT_APP_BUILD)),
+        minify: !noMinify,
+    };
+}
+function assertDirArg(path, argName, make) {
+    let dirStats;
+    try {
+        dirStats = statSync(path);
+    }
+    catch {
+        if (!make) {
+            throw new Error(`Error: the provided${argName ? ` "${argName}"` : ""} input is not a valid path`);
+        }
+        mkdirSync(path);
+        return;
+    }
+    if (!dirStats.isDirectory()) {
+        throw new Error(`Error: the provided${argName ? ` "${argName}"` : ""} input is not a directory`);
+    }
+}

package/dist/cli/build/bundle-server.d.ts

@@ -0,0 +1,6 @@
+import type { BuildOptions } from "@opennextjs/aws/build/helper.js";
+import { Config } from "../config.js";
+/**
+ * Bundle the Open Next server.
+ */
+export declare function bundleServer(config: Config, openNextOptions: BuildOptions): Promise<void>;

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

@@ -0,0 +1,188 @@
+import fs from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { build } from "esbuild";
+import * as patches from "./patches/index.js";
+/** The dist directory of the Cloudflare adapter package */
+const packageDistDir = path.join(path.dirname(fileURLToPath(import.meta.url)), "../..");
+/**
+ * Bundle the Open Next server.
+ */
+export async function bundleServer(config, openNextOptions) {
+    patches.copyPackageCliFiles(packageDistDir, config, openNextOptions);
+    const nextConfigStr = fs
+        .readFileSync(path.join(config.paths.output.standaloneApp, "server.js"), "utf8")
+        ?.match(/const nextConfig = ({.+?})\n/)?.[1] ?? {};
+    console.log(`\x1b[35m⚙️ Bundling the OpenNext server...\n\x1b[0m`);
+    patches.patchWranglerDeps(config);
+    patches.updateWebpackChunksFile(config);
+    const { appBuildOutputPath, appPath, outputDir, monorepoRoot } = openNextOptions;
+    const outputPath = path.join(outputDir, "server-functions", "default");
+    const packagePath = path.relative(monorepoRoot, appBuildOutputPath);
+    const openNextServer = path.join(outputPath, packagePath, `index.mjs`);
+    const openNextServerBundle = path.join(outputPath, packagePath, `handler.mjs`);
+    await build({
+        entryPoints: [openNextServer],
+        bundle: true,
+        outfile: openNextServerBundle,
+        format: "esm",
+        target: "esnext",
+        minify: false,
+        plugins: [createFixRequiresESBuildPlugin(config)],
+        external: ["./middleware/handler.mjs"],
+        alias: {
+            // Note: we apply an empty shim to next/dist/compiled/ws because it generates two `eval`s:
+            //   eval("require")("bufferutil");
+            //   eval("require")("utf-8-validate");
+            "next/dist/compiled/ws": path.join(config.paths.internal.templates, "shims", "empty.js"),
+            // Note: we apply an empty shim to next/dist/compiled/edge-runtime since (amongst others) it generated the following `eval`:
+            //   eval(getModuleCode)(module, module.exports, throwingRequire, params.context, ...Object.values(params.scopedContext));
+            //   which comes from https://github.com/vercel/edge-runtime/blob/6e96b55f/packages/primitives/src/primitives/load.js#L57-L63
+            // QUESTION: Why did I encountered this but mhart didn't?
+            "next/dist/compiled/edge-runtime": path.join(config.paths.internal.templates, "shims", "empty.js"),
+            // `@next/env` is a library Next.js uses for loading dotenv files, for obvious reasons we need to stub it here
+            // source: https://github.com/vercel/next.js/tree/0ac10d79720/packages/next-env
+            "@next/env": path.join(config.paths.internal.templates, "shims", "env.js"),
+        },
+        define: {
+            // config file used by Next.js, see: https://github.com/vercel/next.js/blob/68a7128/packages/next/src/build/utils.ts#L2137-L2139
+            "process.env.__NEXT_PRIVATE_STANDALONE_CONFIG": JSON.stringify(nextConfigStr),
+            // Next.js tried to access __dirname so we need to define it
+            __dirname: '""',
+            // 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",
+            // Ask mhart if he can explain why the `define`s below are necessary
+            "process.env.NEXT_RUNTIME": '"nodejs"',
+            "process.env.NODE_ENV": '"production"',
+            "process.env.NEXT_MINIMAL": "true",
+        },
+        // We need to set platform to node so that esbuild doesn't complain about the node imports
+        platform: "node",
+        banner: {
+            js: `
+// __dirname is 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 ??= "";
+
+// 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) {
+      init = {
+        ...init,
+        cache: undefined,
+        // https://github.com/cloudflare/workerd/issues/2746
+        // https://github.com/cloudflare/workerd/issues/3245
+        body: 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()};
+`,
+        },
+    });
+    await updateWorkerBundledCode(openNextServerBundle, config, openNextOptions);
+    const isMonorepo = monorepoRoot !== appPath;
+    if (isMonorepo) {
+        const packagePosixPath = packagePath.split(path.sep).join(path.posix.sep);
+        fs.writeFileSync(path.join(outputPath, "handler.mjs"), `export * from "./${packagePosixPath}/handler.mjs";`);
+    }
+    console.log(`\x1b[35mWorker saved in \`${openNextServerBundle}\` 🚀\n\x1b[0m`);
+}
+/**
+ * This function applies string replacements on the bundled worker code necessary to get it to run in workerd
+ *
+ * Needless to say all the logic in this function is something we should avoid as much as possible!
+ *
+ * @param workerOutputFile
+ * @param config
+ */
+async function updateWorkerBundledCode(workerOutputFile, config, openNextOptions) {
+    const code = await readFile(workerOutputFile, "utf8");
+    const patchedCode = await patchCodeWithValidations(code, [
+        ["require", patches.patchRequire],
+        ["`buildId` function", (code) => patches.patchBuildId(code, config)],
+        ["`loadManifest` function", (code) => patches.patchLoadManifest(code, config)],
+        ["next's require", (code) => patches.inlineNextRequire(code, config)],
+        ["`findDir` function", (code) => patches.patchFindDir(code, config)],
+        ["`evalManifest` function", (code) => patches.inlineEvalManifest(code, config)],
+        ["cacheHandler", (code) => patches.patchCache(code, openNextOptions)],
+        [
+            "'require(this.middlewareManifestPath)'",
+            (code) => patches.inlineMiddlewareManifestRequire(code, config),
+        ],
+        ["exception bubbling", patches.patchExceptionBubbling],
+        ["`loadInstrumentationModule` function", patches.patchLoadInstrumentationModule],
+        [
+            "`patchAsyncStorage` call",
+            (code) => code
+                // TODO: implement for cf (possibly in @opennextjs/aws)
+                .replace("patchAsyncStorage();", "//patchAsyncStorage();"),
+        ],
+        [
+            '`eval("require")` calls',
+            (code) => code.replaceAll('eval("require")', "require"),
+            { isOptional: true },
+        ],
+        [
+            "`require.resolve` call",
+            // workers do not support dynamic require nor require.resolve
+            (code) => code.replace('require.resolve("./cache.cjs")', '"unused"'),
+        ],
+    ]);
+    await writeFile(workerOutputFile, patchedCode);
+}
+function createFixRequiresESBuildPlugin(config) {
+    return {
+        name: "replaceRelative",
+        setup(build) {
+            // Note: we (empty) shim require-hook modules as they generate problematic code that uses requires
+            build.onResolve({ filter: /^\.\/require-hook$/ }, () => ({
+                path: path.join(config.paths.internal.templates, "shims", "empty.js"),
+            }));
+        },
+    };
+}
+/**
+ * Applies multiple code patches in order to a given piece of code, at each step it validates that the code
+ * has actually been patched/changed, if not an error is thrown
+ *
+ * @param code the code to apply the patches to
+ * @param patches array of tuples, containing a string indicating the target of the patching (for logging) and
+ *                a patching function that takes a string (pre-patch code) and returns a string (post-patch code)
+ * @returns the patched code
+ */
+async function patchCodeWithValidations(code, patches) {
+    console.log(`Applying code patches:`);
+    let patchedCode = code;
+    for (const [target, patchFunction, opts] of patches) {
+        console.log(` - patching ${target}`);
+        const prePatchCode = patchedCode;
+        patchedCode = await patchFunction(patchedCode);
+        if (!opts?.isOptional && prePatchCode === patchedCode) {
+            throw new Error(`Failed to patch ${target}`);
+        }
+    }
+    console.log(`All ${patches.length} patches applied\n`);
+    return patchedCode;
+}

package/dist/cli/build/index.d.ts

@@ -0,0 +1,9 @@
+import type { ProjectOptions } from "../config.js";
+/**
+ * Builds the application in a format that can be passed to workerd
+ *
+ * It saves the output in a `.worker-next` directory
+ *
+ * @param projectOpts The options for the project
+ */
+export declare function build(projectOpts: ProjectOptions): Promise<void>;