@opennextjs/cloudflare 0.0.0-e62af72 → 0.0.3

package/dist/cli/index.mjs

@@ -1,8 +1,10 @@
 #!/usr/bin/env node
 import {
+  NEXT_META_SUFFIX,
+  SEED_DATA_DIR,
   __commonJS,
   __toESM
-} from "./chunk-UJCSKKID.mjs";
+} from "./chunk-F7LECSR5.mjs";
 
 // ../../node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js
 var require_balanced_match = __commonJS({
@@ -213,68 +215,172 @@ var require_brace_expansion = __commonJS({
   }
 });
 
-// src/cli/index.ts
-import { resolve as resolve2 } from "node:path";
-
-// src/cli/args.ts
-import { mkdirSync, statSync } from "node:fs";
-import { parseArgs } from "node:util";
-import { resolve } from "node:path";
-function getArgs() {
-  const {
-    values: { skipBuild: skipBuild2, output }
-  } = parseArgs({
-    options: {
-      skipBuild: {
-        type: "boolean",
-        short: "s",
-        default: false
-      },
-      output: {
-        type: "string",
-        short: "o"
-      }
-    },
-    allowPositionals: false
-  });
-  const outputDir2 = output ? resolve(output) : void 0;
-  if (outputDir2) {
-    assertDirArg(outputDir2, "output", true);
+// src/cli/config.ts
+import path, { relative } from "node:path";
+import { readdirSync, statSync } from "node:fs";
+var PACKAGE_NAME = "@opennextjs/cloudflare";
+var UserConfig = {
+  cache: {
+    bindingName: "NEXT_CACHE_WORKERS_KV"
   }
+};
+function getConfig(appDir, outputDir2) {
+  const dotNext = path.join(outputDir2, ".next");
+  const appPath = getNextjsApplicationPath(dotNext).replace(/\/$/, "");
+  const standaloneRoot = path.join(dotNext, "standalone");
+  const standaloneApp = path.join(standaloneRoot, appPath);
+  const standaloneAppDotNext = path.join(standaloneApp, ".next");
+  const standaloneAppServer = path.join(standaloneAppDotNext, "server");
+  const nodeModules = path.join(standaloneApp, "node_modules");
+  const internalPackage = path.join(nodeModules, ...PACKAGE_NAME.split("/"));
   return {
-    outputDir: outputDir2,
-    skipBuild: skipBuild2 || ["1", "true", "yes"].includes(String(process.env.SKIP_NEXT_APP_BUILD))
+    buildTimestamp: Date.now(),
+    paths: {
+      nextApp: appDir,
+      builderOutput: outputDir2,
+      dotNext,
+      standaloneRoot,
+      standaloneApp,
+      standaloneAppDotNext,
+      standaloneAppServer,
+      internalPackage
+    },
+    cache: {
+      kvBindingName: UserConfig.cache.bindingName
+    },
+    internalPackageName: PACKAGE_NAME
   };
 }
-function assertDirArg(path13, argName, make) {
-  let dirStats;
+function containsDotNextDir(folder) {
   try {
-    dirStats = statSync(path13);
+    return statSync(path.join(folder, ".next")).isDirectory();
   } catch {
-    if (!make) {
-      throw new Error(`Error: the provided${argName ? ` "${argName}"` : ""} input is not a valid path`);
+    return false;
+  }
+}
+function getNextjsApplicationPath(dotNextDir) {
+  const serverPath = findServerParentPath(dotNextDir);
+  if (!serverPath) {
+    throw new Error(`Unexpected Error: no \`.next/server\` folder could be found in \`${serverPath}\``);
+  }
+  return relative(path.join(dotNextDir, "standalone"), serverPath);
+}
+function findServerParentPath(parentPath) {
+  try {
+    if (statSync(path.join(parentPath, ".next", "server")).isDirectory()) {
+      return parentPath;
     }
-    mkdirSync(path13);
-    return;
+  } catch {
   }
-  if (!dirStats.isDirectory()) {
-    throw new Error(`Error: the provided${argName ? ` "${argName}"` : ""} input is not a directory`);
+  const folders = readdirSync(parentPath);
+  for (const folder of folders) {
+    const subFolder = path.join(parentPath, folder);
+    if (statSync(path.join(parentPath, folder)).isDirectory()) {
+      const dirServerPath = findServerParentPath(subFolder);
+      if (dirServerPath) {
+        return dirServerPath;
+      }
+    }
   }
 }
 
-// src/cli/index.ts
-import { existsSync as existsSync4 } from "node:fs";
+// ../../node_modules/.pnpm/package-manager-detector@0.2.0/node_modules/package-manager-detector/dist/constants.mjs
+var AGENTS = [
+  "npm",
+  "yarn",
+  "yarn@berry",
+  "pnpm",
+  "pnpm@6",
+  "bun"
+];
+var LOCKS = {
+  "bun.lockb": "bun",
+  "pnpm-lock.yaml": "pnpm",
+  "yarn.lock": "yarn",
+  "package-lock.json": "npm",
+  "npm-shrinkwrap.json": "npm"
+};
 
-// src/cli/build/index.ts
-import { rm } from "node:fs/promises";
+// ../../node_modules/.pnpm/package-manager-detector@0.2.0/node_modules/package-manager-detector/dist/detect.mjs
+import fs from "node:fs";
+import fsPromises from "node:fs/promises";
+import path2 from "node:path";
+import process2 from "node:process";
+async function detect({ cwd, onUnknown } = {}) {
+  for (const directory of lookup(cwd)) {
+    for (const lock of Object.keys(LOCKS)) {
+      if (await fileExists(path2.join(directory, lock))) {
+        const name = LOCKS[lock];
+        const result2 = await parsePackageJson(path2.join(directory, "package.json"), onUnknown);
+        if (result2)
+          return result2;
+        else
+          return { name, agent: name };
+      }
+    }
+    const result = await parsePackageJson(path2.join(directory, "package.json"), onUnknown);
+    if (result)
+      return result;
+  }
+  return null;
+}
+function* lookup(cwd = process2.cwd()) {
+  let directory = path2.resolve(cwd);
+  const { root } = path2.parse(directory);
+  while (directory && directory !== root) {
+    yield directory;
+    directory = path2.dirname(directory);
+  }
+}
+async function parsePackageJson(filepath, onUnknown) {
+  if (!filepath || !await fileExists(filepath))
+    return null;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(filepath, "utf8"));
+    let agent;
+    if (typeof pkg.packageManager === "string") {
+      const [name, ver] = pkg.packageManager.replace(/^\^/, "").split("@");
+      let version = ver;
+      if (name === "yarn" && Number.parseInt(ver) > 1) {
+        agent = "yarn@berry";
+        version = "berry";
+        return { name, agent, version };
+      } else if (name === "pnpm" && Number.parseInt(ver) < 7) {
+        agent = "pnpm@6";
+        return { name, agent, version };
+      } else if (AGENTS.includes(name)) {
+        agent = name;
+        return { name, agent, version };
+      } else {
+        return onUnknown?.(pkg.packageManager) ?? null;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function fileExists(filePath) {
+  try {
+    const stats = await fsPromises.stat(filePath);
+    if (stats.isFile()) {
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
 
 // src/cli/build/build-next-app.ts
 import { execSync } from "node:child_process";
-function buildNextjsApp(nextAppDir2) {
-  runNextBuildCommand("pnpm", nextAppDir2);
+async function buildNextjsApp(nextAppDir2) {
+  const pm = await detect();
+  if (!pm) {
+    throw new Error("Fatal Error: package manager detection failed, aborting");
+  }
+  runNextBuildCommand(pm.name, nextAppDir2);
 }
 function runNextBuildCommand(packager, nextAppDir2) {
-  const command = ["bun", "npm"].includes(packager) ? `${packager} next build` : `${packager} next build`;
+  const command = `${packager === "npm" ? "npx" : packager} next build`;
   execSync(command, {
     stdio: "inherit",
     cwd: nextAppDir2,
@@ -289,29 +395,71 @@ function runNextBuildCommand(packager, nextAppDir2) {
 
 // src/cli/build/build-worker.ts
 import { build } from "esbuild";
-import { existsSync as existsSync3, readFileSync as readFileSync4 } from "node:fs";
 import { cp, readFile, writeFile } from "node:fs/promises";
-import path10 from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
-
-// src/cli/build/patches/investigated/patch-require.ts
-function patchRequire(code) {
-  console.log("# patchRequire");
-  return code.replace(/__require\d?\(/g, "require(").replace(/__require\d?\./g, "require.");
-}
+import { existsSync as existsSync5, readFileSync as readFileSync7 } from "node:fs";
 
 // src/cli/build/patches/investigated/copy-package-cli-files.ts
 import { cpSync } from "node:fs";
-import path from "node:path";
+import path3 from "node:path";
 function copyPackageCliFiles(packageDistDir2, config) {
   console.log("# copyPackageTemplateFiles");
-  const sourceDir = path.join(packageDistDir2, "cli");
-  const destinationDir = path.join(config.paths.internalPackage, "cli");
+  const sourceDir = path3.join(packageDistDir2, "cli");
+  const destinationDir = path3.join(config.paths.internalPackage, "cli");
   cpSync(sourceDir, destinationDir, { recursive: true });
 }
 
-// src/cli/build/patches/to-investigate/patch-read-file.ts
-import { readFileSync } from "node:fs";
+// src/cli/build/utils/ts-parse-file.ts
+import * as ts from "ts-morph";
+function tsParseFile(fileContent) {
+  const project = new ts.Project();
+  const sourceFile = project.createSourceFile("file.js", fileContent);
+  return sourceFile;
+}
+
+// src/cli/build/utils/copy-prerendered-routes.ts
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+
+// src/cli/build/utils/read-paths-recursively.ts
+import { join } from "node:path";
+import { readdirSync as readdirSync2 } from "node:fs";
+function readPathsRecursively(dir) {
+  try {
+    const files = readdirSync2(dir, { withFileTypes: true });
+    return files.flatMap((file) => {
+      const filePath = join(dir, file.name);
+      return file.isDirectory() ? readPathsRecursively(filePath) : filePath;
+    });
+  } catch {
+    return [];
+  }
+}
+
+// src/cli/build/utils/copy-prerendered-routes.ts
+function copyPrerenderedRoutes(config) {
+  console.log("# copyPrerenderedRoutes");
+  const serverAppDirPath = join2(config.paths.standaloneAppServer, "app");
+  const prerenderManifestPath = join2(config.paths.standaloneAppDotNext, "prerender-manifest.json");
+  const outputPath = join2(config.paths.builderOutput, "assets", SEED_DATA_DIR);
+  const prerenderManifest = existsSync(prerenderManifestPath) ? JSON.parse(readFileSync(prerenderManifestPath, "utf8")) : {};
+  const prerenderedRoutes = Object.keys(prerenderManifest.routes);
+  const prerenderedAssets = readPathsRecursively(serverAppDirPath).map((fullPath) => ({ fullPath, relativePath: fullPath.replace(serverAppDirPath, "") })).filter(
+    ({ relativePath }) => prerenderedRoutes.includes(relativePath.replace(/\.\w+$/, "").replace(/^\/index$/, "/"))
+  );
+  prerenderedAssets.forEach(({ fullPath, relativePath }) => {
+    const destPath = join2(outputPath, relativePath);
+    mkdirSync(dirname(destPath), { recursive: true });
+    if (fullPath.endsWith(NEXT_META_SUFFIX)) {
+      const data = JSON.parse(readFileSync(fullPath, "utf8"));
+      writeFileSync(destPath, JSON.stringify({ ...data, lastModified: config.buildTimestamp }));
+    } else {
+      copyFileSync(fullPath, destPath);
+    }
+  });
+}
+
+// src/cli/build/build-worker.ts
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // ../../node_modules/.pnpm/minimatch@10.0.1/node_modules/minimatch/dist/esm/index.js
 var import_brace_expansion = __toESM(require_brace_expansion(), 1);
@@ -984,11 +1132,11 @@ var qmarksTestNoExtDot = ([$0]) => {
   return (f) => f.length === len && f !== "." && f !== "..";
 };
 var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-var path2 = {
+var path4 = {
   win32: { sep: "\\" },
   posix: { sep: "/" }
 };
-var sep = defaultPlatform === "win32" ? path2.win32.sep : path2.posix.sep;
+var sep = defaultPlatform === "win32" ? path4.win32.sep : path4.posix.sep;
 minimatch.sep = sep;
 var GLOBSTAR = Symbol("globstar **");
 minimatch.GLOBSTAR = GLOBSTAR;
@@ -3018,7 +3166,7 @@ var LRUCache = class _LRUCache {
 // ../../node_modules/.pnpm/path-scurry@2.0.0/node_modules/path-scurry/dist/esm/index.js
 import { posix, win32 } from "node:path";
 import { fileURLToPath } from "node:url";
-import { lstatSync, readdir as readdirCB, readdirSync, readlinkSync, realpathSync as rps } from "fs";
+import { lstatSync, readdir as readdirCB, readdirSync as readdirSync3, readlinkSync, realpathSync as rps } from "fs";
 import * as actualFS from "node:fs";
 import { lstat, readdir, readlink, realpath } from "node:fs/promises";
 
@@ -3905,7 +4053,7 @@ var realpathSync = rps.native;
 var defaultFS = {
   lstatSync,
   readdir: readdirCB,
-  readdirSync,
+  readdirSync: readdirSync3,
   readlinkSync,
   realpathSync,
   promises: {
@@ -4165,12 +4313,12 @@ var PathBase = class {
   /**
    * Get the Path object referenced by the string path, resolved from this Path
    */
-  resolve(path13) {
-    if (!path13) {
+  resolve(path15) {
+    if (!path15) {
       return this;
     }
-    const rootPath = this.getRootString(path13);
-    const dir = path13.substring(rootPath.length);
+    const rootPath = this.getRootString(path15);
+    const dir = path15.substring(rootPath.length);
     const dirParts = dir.split(this.splitSep);
     const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
     return result;
@@ -4922,8 +5070,8 @@ var PathWin32 = class _PathWin32 extends PathBase {
   /**
    * @internal
    */
-  getRootString(path13) {
-    return win32.parse(path13).root;
+  getRootString(path15) {
+    return win32.parse(path15).root;
   }
   /**
    * @internal
@@ -4969,8 +5117,8 @@ var PathPosix = class _PathPosix extends PathBase {
   /**
    * @internal
    */
-  getRootString(path13) {
-    return path13.startsWith("/") ? "/" : "";
+  getRootString(path15) {
+    return path15.startsWith("/") ? "/" : "";
   }
   /**
    * @internal
@@ -5059,11 +5207,11 @@ var PathScurryBase = class {
   /**
    * Get the depth of a provided path, string, or the cwd
    */
-  depth(path13 = this.cwd) {
-    if (typeof path13 === "string") {
-      path13 = this.cwd.resolve(path13);
+  depth(path15 = this.cwd) {
+    if (typeof path15 === "string") {
+      path15 = this.cwd.resolve(path15);
     }
-    return path13.depth();
+    return path15.depth();
   }
   /**
    * Return the cache of child entries.  Exposed so subclasses can create
@@ -5442,7 +5590,7 @@ var PathScurryBase = class {
     const dirs = /* @__PURE__ */ new Set();
     const queue = [entry];
     let processing = 0;
-    const process2 = () => {
+    const process3 = () => {
       let paused = false;
       while (!paused) {
         const dir = queue.shift();
@@ -5483,9 +5631,9 @@ var PathScurryBase = class {
             }
           }
           if (paused && !results.flowing) {
-            results.once("drain", process2);
+            results.once("drain", process3);
           } else if (!sync2) {
-            process2();
+            process3();
           }
         };
         let sync2 = true;
@@ -5493,7 +5641,7 @@ var PathScurryBase = class {
         sync2 = false;
       }
     };
-    process2();
+    process3();
     return results;
   }
   streamSync(entry = this.cwd, opts = {}) {
@@ -5511,7 +5659,7 @@ var PathScurryBase = class {
     }
     const queue = [entry];
     let processing = 0;
-    const process2 = () => {
+    const process3 = () => {
       let paused = false;
       while (!paused) {
         const dir = queue.shift();
@@ -5545,14 +5693,14 @@ var PathScurryBase = class {
         }
       }
       if (paused && !results.flowing)
-        results.once("drain", process2);
+        results.once("drain", process3);
     };
-    process2();
+    process3();
     return results;
   }
-  chdir(path13 = this.cwd) {
+  chdir(path15 = this.cwd) {
     const oldCwd = this.cwd;
-    this.cwd = typeof path13 === "string" ? this.cwd.resolve(path13) : path13;
+    this.cwd = typeof path15 === "string" ? this.cwd.resolve(path15) : path15;
     this.cwd[setAsCwd](oldCwd);
   }
 };
@@ -5908,8 +6056,8 @@ var MatchRecord = class {
   }
   // match, absolute, ifdir
   entries() {
-    return [...this.store.entries()].map(([path13, n]) => [
-      path13,
+    return [...this.store.entries()].map(([path15, n]) => [
+      path15,
       !!(n & 2),
       !!(n & 1)
     ]);
@@ -6114,9 +6262,9 @@ var GlobUtil = class {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path13, opts) {
+  constructor(patterns, path15, opts) {
     this.patterns = patterns;
-    this.path = path13;
+    this.path = path15;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -6135,11 +6283,11 @@ var GlobUtil = class {
       });
     }
   }
-  #ignored(path13) {
-    return this.seen.has(path13) || !!this.#ignore?.ignored?.(path13);
+  #ignored(path15) {
+    return this.seen.has(path15) || !!this.#ignore?.ignored?.(path15);
   }
-  #childrenIgnored(path13) {
-    return !!this.#ignore?.childrenIgnored?.(path13);
+  #childrenIgnored(path15) {
+    return !!this.#ignore?.childrenIgnored?.(path15);
   }
   // backpressure mechanism
   pause() {
@@ -6354,8 +6502,8 @@ var GlobUtil = class {
 };
 var GlobWalker = class extends GlobUtil {
   matches = /* @__PURE__ */ new Set();
-  constructor(patterns, path13, opts) {
-    super(patterns, path13, opts);
+  constructor(patterns, path15, opts) {
+    super(patterns, path15, opts);
   }
   matchEmit(e) {
     this.matches.add(e);
@@ -6392,8 +6540,8 @@ var GlobWalker = class extends GlobUtil {
 };
 var GlobStream = class extends GlobUtil {
   results;
-  constructor(patterns, path13, opts) {
-    super(patterns, path13, opts);
+  constructor(patterns, path15, opts) {
+    super(patterns, path15, opts);
     this.results = new Minipass({
       signal: this.signal,
       objectMode: true
@@ -6686,67 +6834,61 @@ var glob = Object.assign(glob_, {
 });
 glob.glob = glob;
 
-// src/cli/build/patches/to-investigate/patch-read-file.ts
-import path3 from "node:path";
-function patchReadFile(code, config) {
-  console.log("# patchReadFile");
-  code = code.replace(
-    "getBuildId() {",
-    `getBuildId() {
-      return ${JSON.stringify(readFileSync(path3.join(config.paths.standaloneAppDotNext, "BUILD_ID"), "utf-8"))};
-    `
-  );
-  const manifestJsons = globSync(path3.join(config.paths.standaloneAppDotNext, "**", "*-manifest.json")).map(
-    (file) => file.replace(config.paths.standaloneApp + "/", "")
-  );
-  code = code.replace(
-    /function loadManifest\((.+?), .+?\) {/,
+// src/cli/build/patches/to-investigate/inline-eval-manifest.ts
+import path5 from "node:path";
+function inlineEvalManifest(code, config) {
+  console.log("# inlineEvalManifest");
+  const manifestJss = globSync(
+    path5.join(config.paths.standaloneAppDotNext, "**", "*_client-reference-manifest.js")
+  ).map((file) => file.replace(`${config.paths.standaloneApp}/`, ""));
+  return code.replace(
+    /function evalManifest\((.+?), .+?\) {/,
     `$&
-    ${manifestJsons.map(
-      (manifestJson) => `
-          if ($1.endsWith("${manifestJson}")) {
-            return ${readFileSync(path3.join(config.paths.standaloneApp, manifestJson), "utf-8")};
-          }
-        `
+		${manifestJss.map(
+      (manifestJs) => `
+			  if ($1.endsWith("${manifestJs}")) {
+				require("${path5.join(config.paths.standaloneApp, manifestJs)}");
+				return {
+				  __RSC_MANIFEST: {
+					"${manifestJs.replace(".next/server/app", "").replace("_client-reference-manifest.js", "")}": globalThis.__RSC_MANIFEST["${manifestJs.replace(".next/server/app", "").replace("_client-reference-manifest.js", "")}"],
+				  },
+				};
+			  }
+			`
     ).join("\n")}
-    throw new Error("Unknown loadManifest: " + $1);
-    `
+		throw new Error("Unknown evalManifest: " + $1);
+		`
   );
-  return code;
 }
 
-// src/cli/build/patches/to-investigate/patch-find-dir.ts
-import path4 from "node:path";
-import { existsSync } from "node:fs";
-function patchFindDir(code, config) {
-  console.log("# patchFindDir");
-  return code.replace(
-    "function findDir(dir, name) {",
-    `function findDir(dir, name) {
-			if (dir.endsWith(".next/server")) {
-			if (name === "app") {
-			  return ${existsSync(`${path4.join(config.paths.standaloneAppServer, "app")}`)};
-	    }
-			if (name === "pages") {
-			  return ${existsSync(`${path4.join(config.paths.standaloneAppServer, "pages")}`)};
-	    }
-		}
-		throw new Error("Unknown findDir call: " + dir + " " + name);
-		`
+// src/cli/build/patches/to-investigate/inline-middleware-manifest-require.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import path6 from "node:path";
+function inlineMiddlewareManifestRequire(code, config) {
+  console.log("# inlineMiddlewareManifestRequire");
+  const middlewareManifestPath = path6.join(config.paths.standaloneAppServer, "middleware-manifest.json");
+  const middlewareManifest = existsSync2(middlewareManifestPath) ? JSON.parse(readFileSync2(middlewareManifestPath, "utf-8")) : {};
+  const patchedCode = code.replace(
+    "require(this.middlewareManifestPath)",
+    JSON.stringify(middlewareManifest)
   );
+  if (patchedCode === code) {
+    throw new Error("Patch `inlineMiddlewareManifestRequire` not applied");
+  }
+  return patchedCode;
 }
 
 // src/cli/build/patches/to-investigate/inline-next-require.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "node:fs";
-import path5 from "node:path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import path7 from "node:path";
 function inlineNextRequire(code, config) {
   console.log("# inlineNextRequire");
-  const pagesManifestFile = path5.join(config.paths.standaloneAppServer, "pages-manifest.json");
-  const appPathsManifestFile = path5.join(config.paths.standaloneAppServer, "app-paths-manifest.json");
-  const pagesManifestFiles = existsSync2(pagesManifestFile) ? Object.values(JSON.parse(readFileSync2(pagesManifestFile, "utf-8"))).map(
+  const pagesManifestFile = path7.join(config.paths.standaloneAppServer, "pages-manifest.json");
+  const appPathsManifestFile = path7.join(config.paths.standaloneAppServer, "app-paths-manifest.json");
+  const pagesManifestFiles = existsSync3(pagesManifestFile) ? Object.values(JSON.parse(readFileSync3(pagesManifestFile, "utf-8"))).map(
     (file) => ".next/server/" + file
   ) : [];
-  const appPathsManifestFiles = existsSync2(appPathsManifestFile) ? Object.values(JSON.parse(readFileSync2(appPathsManifestFile, "utf-8"))).map(
+  const appPathsManifestFiles = existsSync3(appPathsManifestFile) ? Object.values(JSON.parse(readFileSync3(appPathsManifestFile, "utf-8"))).map(
     (file) => ".next/server/" + file
   ) : [];
   const allManifestFiles = pagesManifestFiles.concat(appPathsManifestFiles);
@@ -6758,14 +6900,14 @@ function inlineNextRequire(code, config) {
     ${htmlPages.map(
       (htmlPage) => `
           if (pagePath.endsWith("${htmlPage}")) {
-            return ${JSON.stringify(readFileSync2(path5.join(config.paths.standaloneApp, htmlPage), "utf-8"))};
+            return ${JSON.stringify(readFileSync3(path7.join(config.paths.standaloneApp, htmlPage), "utf-8"))};
           }
         `
     ).join("\n")}
     ${pageModules.map(
       (module) => `
           if (pagePath.endsWith("${module}")) {
-            return require("${path5.join(config.paths.standaloneApp, module)}");
+            return require("${path7.join(config.paths.standaloneApp, module)}");
           }
         `
     ).join("\n")}
@@ -6774,69 +6916,129 @@ function inlineNextRequire(code, config) {
   );
 }
 
-// src/cli/build/patches/to-investigate/inline-eval-manifest.ts
-import path6 from "node:path";
-function inlineEvalManifest(code, config) {
-  console.log("# inlineEvalManifest");
-  const manifestJss = globSync(
-    path6.join(config.paths.standaloneAppDotNext, "**", "*_client-reference-manifest.js")
-  ).map((file) => file.replace(`${config.paths.standaloneApp}/`, ""));
+// src/cli/build/patches/investigated/patch-cache.ts
+import path8 from "node:path";
+function patchCache(code, config) {
+  console.log("# patchCache");
+  const cacheHandler = path8.join(config.paths.internalPackage, "cli", "cache-handler", "index.mjs");
+  const patchedCode = code.replace(
+    "const { cacheHandler } = this.nextConfig;",
+    `const cacheHandler = null;
+CacheHandler = (await import('${cacheHandler}')).OpenNextCacheHandler;
+CacheHandler.maybeKVNamespace = process.env["${config.cache.kvBindingName}"];
+`
+  );
+  if (patchedCode === code) {
+    throw new Error("Cache patch not applied");
+  }
+  return patchedCode;
+}
+
+// src/cli/build/patches/to-investigate/patch-exception-bubbling.ts
+function patchExceptionBubbling(code) {
+  console.log("# patchExceptionBubbling");
+  const patchedCode = code.replace('_nextBubbleNoFallback = "1"', "_nextBubbleNoFallback = undefined");
+  if (patchedCode === code) {
+    throw new Error("Patch `patchExceptionBubbling` not applied");
+  }
+  return patchedCode;
+}
+
+// src/cli/build/patches/to-investigate/patch-find-dir.ts
+import { existsSync as existsSync4 } from "node:fs";
+import path9 from "node:path";
+function patchFindDir(code, config) {
+  console.log("# patchFindDir");
   return code.replace(
-    /function evalManifest\((.+?), .+?\) {/,
+    "function findDir(dir, name) {",
+    `function findDir(dir, name) {
+			if (dir.endsWith(".next/server")) {
+			if (name === "app") {
+			  return ${existsSync4(`${path9.join(config.paths.standaloneAppServer, "app")}`)};
+	    }
+			if (name === "pages") {
+			  return ${existsSync4(`${path9.join(config.paths.standaloneAppServer, "pages")}`)};
+	    }
+		}
+		throw new Error("Unknown findDir call: " + dir + " " + name);
+		`
+  );
+}
+
+// src/cli/build/patches/to-investigate/patch-read-file.ts
+import path10 from "node:path";
+import { readFileSync as readFileSync4 } from "node:fs";
+function patchReadFile(code, config) {
+  console.log("# patchReadFile");
+  code = code.replace(
+    "getBuildId() {",
+    `getBuildId() {
+      return ${JSON.stringify(readFileSync4(path10.join(config.paths.standaloneAppDotNext, "BUILD_ID"), "utf-8"))};
+    `
+  );
+  const manifestJsons = globSync(path10.join(config.paths.standaloneAppDotNext, "**", "*-manifest.json")).map(
+    (file) => file.replace(config.paths.standaloneApp + "/", "")
+  );
+  code = code.replace(
+    /function loadManifest\((.+?), .+?\) {/,
     `$&
-		${manifestJss.map(
-      (manifestJs) => `
-			  if ($1.endsWith("${manifestJs}")) {
-				require("${path6.join(config.paths.standaloneApp, manifestJs)}");
-				return {
-				  __RSC_MANIFEST: {
-					"${manifestJs.replace(".next/server/app", "").replace("_client-reference-manifest.js", "")}": globalThis.__RSC_MANIFEST["${manifestJs.replace(".next/server/app", "").replace("_client-reference-manifest.js", "")}"],
-				  },
-				};
-			  }
-			`
+    ${manifestJsons.map(
+      (manifestJson) => `
+          if ($1.endsWith("${manifestJson}")) {
+            return ${readFileSync4(path10.join(config.paths.standaloneApp, manifestJson), "utf-8")};
+          }
+        `
     ).join("\n")}
-		throw new Error("Unknown evalManifest: " + $1);
-		`
+    throw new Error("Unknown loadManifest: " + $1);
+    `
   );
+  return code;
+}
+
+// src/cli/build/patches/investigated/patch-require.ts
+function patchRequire(code) {
+  console.log("# patchRequire");
+  return code.replace(/__require\d?\(/g, "require(").replace(/__require\d?\./g, "require.");
 }
 
 // src/cli/build/patches/to-investigate/wrangler-deps.ts
-import path7 from "node:path";
-import fs, { writeFileSync } from "node:fs";
+import { readFileSync as readFileSync5, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import path11 from "node:path";
 function patchWranglerDeps(config) {
   console.log("# patchWranglerDeps");
-  const pagesRuntimeFile = path7.join(
-    config.paths.standaloneApp,
-    "node_modules",
-    "next",
-    "dist",
-    "compiled",
-    "next-server",
-    "pages.runtime.prod.js"
+  const distPath = getDistPath(config);
+  const pagesRuntimeFile = path11.join(distPath, "compiled", "next-server", "pages.runtime.prod.js");
+  const patchedPagesRuntime = readFileSync5(pagesRuntimeFile, "utf-8").replace(
+    `e.exports=require("critters")`,
+    `e.exports={}`
   );
-  const patchedPagesRuntime = fs.readFileSync(pagesRuntimeFile, "utf-8").replace(`e.exports=require("critters")`, `e.exports={}`);
-  fs.writeFileSync(pagesRuntimeFile, patchedPagesRuntime);
-  const tracerFile = path7.join(
-    config.paths.standaloneApp,
-    "node_modules",
-    "next",
-    "dist",
-    "server",
-    "lib",
-    "trace",
-    "tracer.js"
+  writeFileSync2(pagesRuntimeFile, patchedPagesRuntime);
+  const tracerFile = path11.join(distPath, "server", "lib", "trace", "tracer.js");
+  const patchedTracer = readFileSync5(tracerFile, "utf-8").replaceAll(
+    /\w+\s*=\s*require\([^/]*opentelemetry.*\)/g,
+    `throw new Error("@opentelemetry/api")`
   );
-  const pacthedTracer = fs.readFileSync(tracerFile, "utf-8").replaceAll(/\w+\s*=\s*require\([^/]*opentelemetry.*\)/g, `throw new Error("@opentelemetry/api")`);
-  writeFileSync(tracerFile, pacthedTracer);
+  writeFileSync2(tracerFile, patchedTracer);
+}
+function getDistPath(config) {
+  for (const root of [config.paths.standaloneApp, config.paths.standaloneRoot]) {
+    try {
+      const distPath = path11.join(root, "node_modules", "next", "dist");
+      if (statSync2(distPath).isDirectory()) return distPath;
+    } catch {
+    }
+  }
+  throw new Error("Unexpected error: unable to detect the node_modules/next/dist directory");
 }
 
+// src/cli/build/build-worker.ts
+import path13 from "node:path";
+
 // src/cli/build/patches/investigated/update-webpack-chunks-file/index.ts
-import { readdirSync as readdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
-import path8 from "node:path";
+import { readFileSync as readFileSync6, readdirSync as readdirSync4, writeFileSync as writeFileSync3 } from "node:fs";
 
 // src/cli/build/patches/investigated/update-webpack-chunks-file/get-chunk-installation-identifiers.ts
-import * as ts from "ts-morph";
+import * as ts2 from "ts-morph";
 async function getChunkInstallationIdentifiers(sourceFile) {
   const installChunkDeclaration = getInstallChunkDeclaration(sourceFile);
   const installedChunksDeclaration = getInstalledChunksDeclaration(sourceFile, installChunkDeclaration);
@@ -6846,19 +7048,19 @@ async function getChunkInstallationIdentifiers(sourceFile) {
   };
 }
 function getInstallChunkDeclaration(sourceFile) {
-  const installChunkDeclaration = sourceFile.getDescendantsOfKind(ts.SyntaxKind.VariableDeclaration).find((declaration) => {
-    const arrowFunction = declaration.getInitializerIfKind(ts.SyntaxKind.ArrowFunction);
+  const installChunkDeclaration = sourceFile.getDescendantsOfKind(ts2.SyntaxKind.VariableDeclaration).find((declaration) => {
+    const arrowFunction = declaration.getInitializerIfKind(ts2.SyntaxKind.ArrowFunction);
     if (!arrowFunction) return false;
     const functionParameters = arrowFunction.getParameters();
     if (functionParameters.length !== 1) return false;
-    const arrowFunctionBodyBlock = arrowFunction.getFirstChildByKind(ts.SyntaxKind.Block);
+    const arrowFunctionBodyBlock = arrowFunction.getFirstChildByKind(ts2.SyntaxKind.Block);
     if (!arrowFunctionBodyBlock) return false;
     const statementKinds = arrowFunctionBodyBlock.getStatements().map((statement) => statement.getKind());
-    const forInStatements = statementKinds.filter((s) => s === ts.SyntaxKind.ForInStatement);
-    const forStatements = statementKinds.filter((s) => s === ts.SyntaxKind.ForStatement);
+    const forInStatements = statementKinds.filter((s) => s === ts2.SyntaxKind.ForInStatement);
+    const forStatements = statementKinds.filter((s) => s === ts2.SyntaxKind.ForStatement);
     if (forInStatements.length !== 1 || forStatements.length !== 1) return false;
     const parameterName = functionParameters[0].getText();
-    const functionParameterAccessedProperties = arrowFunctionBodyBlock.getDescendantsOfKind(ts.SyntaxKind.PropertyAccessExpression).filter(
+    const functionParameterAccessedProperties = arrowFunctionBodyBlock.getDescendantsOfKind(ts2.SyntaxKind.PropertyAccessExpression).filter(
       (propertyAccessExpression) => propertyAccessExpression.getExpression().getText() === parameterName
     ).map((propertyAccessExpression) => propertyAccessExpression.getName());
     if (functionParameterAccessedProperties.join(", ") !== "modules, ids, runtime") return false;
@@ -6870,22 +7072,22 @@ function getInstallChunkDeclaration(sourceFile) {
   return installChunkDeclaration;
 }
 function getInstalledChunksDeclaration(sourceFile, installChunkDeclaration) {
-  const allVariableDeclarations = sourceFile.getDescendantsOfKind(ts.SyntaxKind.VariableDeclaration);
+  const allVariableDeclarations = sourceFile.getDescendantsOfKind(ts2.SyntaxKind.VariableDeclaration);
   const installChunkDeclarationIdx = allVariableDeclarations.findIndex(
     (declaration) => declaration === installChunkDeclaration
   );
   const installedChunksDeclaration = allVariableDeclarations[installChunkDeclarationIdx - 1];
-  if (!installedChunksDeclaration?.getInitializer()?.isKind(ts.SyntaxKind.ObjectLiteralExpression)) {
+  if (!installedChunksDeclaration?.getInitializer()?.isKind(ts2.SyntaxKind.ObjectLiteralExpression)) {
     throw new Error("ERROR: unable to find the installedChunks declaration");
   }
   return installedChunksDeclaration;
 }
 
 // src/cli/build/patches/investigated/update-webpack-chunks-file/get-file-content-with-updated-webpack-f-require-code.ts
-import * as ts2 from "ts-morph";
+import * as ts3 from "ts-morph";
 async function getFileContentWithUpdatedWebpackFRequireCode(sourceFile, { installedChunks, installChunk }, chunks) {
-  const webpackFRequireFunction = sourceFile.getDescendantsOfKind(ts2.SyntaxKind.ArrowFunction).find((arrowFunction) => {
-    const binaryExpression = arrowFunction.getFirstAncestorByKind(ts2.SyntaxKind.BinaryExpression);
+  const webpackFRequireFunction = sourceFile.getDescendantsOfKind(ts3.SyntaxKind.ArrowFunction).find((arrowFunction) => {
+    const binaryExpression = arrowFunction.getFirstAncestorByKind(ts3.SyntaxKind.BinaryExpression);
     if (!binaryExpression) return false;
     const binaryExpressionLeft = binaryExpression.getLeft();
     if (!binaryExpressionLeft.getText().endsWith(".f.require")) return false;
@@ -6894,16 +7096,16 @@ async function getFileContentWithUpdatedWebpackFRequireCode(sourceFile, { instal
     const binaryExpressionRight = binaryExpression.getRight();
     if (binaryExpressionRight !== arrowFunction) return false;
     const arrowFunctionBody = arrowFunction.getBody();
-    if (!arrowFunctionBody.isKind(ts2.SyntaxKind.Block)) return false;
+    if (!arrowFunctionBody.isKind(ts3.SyntaxKind.Block)) return false;
     const arrowFunctionBodyText = arrowFunctionBody.getText();
     const functionUsesChunkInstallationVariables = arrowFunctionBodyText.includes(installChunk) && arrowFunctionBodyText.includes(installedChunks);
     if (!functionUsesChunkInstallationVariables) return false;
     const functionParameters = arrowFunction.getParameters();
     if (functionParameters.length !== 2) return false;
-    const callsInstallChunk = arrowFunctionBody.getDescendantsOfKind(ts2.SyntaxKind.CallExpression).some((callExpression) => callExpression.getExpression().getText() === installChunk);
+    const callsInstallChunk = arrowFunctionBody.getDescendantsOfKind(ts3.SyntaxKind.CallExpression).some((callExpression) => callExpression.getExpression().getText() === installChunk);
     if (!callsInstallChunk) return false;
     const functionFirstParameterName = functionParameters[0]?.getName();
-    const accessesInstalledChunksUsingItsFirstParameter = arrowFunctionBody.getDescendantsOfKind(ts2.SyntaxKind.ElementAccessExpression).some((elementAccess) => {
+    const accessesInstalledChunksUsingItsFirstParameter = arrowFunctionBody.getDescendantsOfKind(ts3.SyntaxKind.ElementAccessExpression).some((elementAccess) => {
       return elementAccess.getExpression().getText() === installedChunks && elementAccess.getArgumentExpression()?.getText() === functionFirstParameterName;
     });
     if (!accessesInstalledChunksUsingItsFirstParameter) return false;
@@ -6925,14 +7127,6 @@ if(${chunkId} === ${chunk}) return ${installChunk}(require("./chunks/${chunk}.js
   return sourceFile.print();
 }
 
-// src/cli/build/utils/ts-parse-file.ts
-import * as ts3 from "ts-morph";
-function tsParseFile(fileContent) {
-  const project = new ts3.Project();
-  const sourceFile = project.createSourceFile("file.js", fileContent);
-  return sourceFile;
-}
-
 // src/cli/build/patches/investigated/update-webpack-chunks-file/get-updated-webpack-chunks-file-content.ts
 async function getUpdatedWebpackChunksFileContent(fileContent, chunks) {
   const tsSourceFile = tsParseFile(fileContent);
@@ -6946,59 +7140,43 @@ async function getUpdatedWebpackChunksFileContent(fileContent, chunks) {
 }
 
 // src/cli/build/patches/investigated/update-webpack-chunks-file/index.ts
+import path12 from "node:path";
 async function updateWebpackChunksFile(config) {
   console.log("# updateWebpackChunksFile");
-  const webpackRuntimeFile = path8.join(config.paths.standaloneAppServer, "webpack-runtime.js");
-  const fileContent = readFileSync3(webpackRuntimeFile, "utf-8");
-  const chunks = readdirSync2(path8.join(config.paths.standaloneAppServer, "chunks")).filter((chunk) => /^\d+\.js$/.test(chunk)).map((chunk) => {
+  const webpackRuntimeFile = path12.join(config.paths.standaloneAppServer, "webpack-runtime.js");
+  const fileContent = readFileSync6(webpackRuntimeFile, "utf-8");
+  const chunks = readdirSync4(path12.join(config.paths.standaloneAppServer, "chunks")).filter((chunk) => /^\d+\.js$/.test(chunk)).map((chunk) => {
     console.log(` - chunk ${chunk}`);
     return chunk.replace(/\.js$/, "");
   });
   const updatedFileContent = await getUpdatedWebpackChunksFileContent(fileContent, chunks);
-  writeFileSync2(webpackRuntimeFile, updatedFileContent);
-}
-
-// src/cli/build/patches/investigated/patch-cache.ts
-import path9 from "node:path";
-function patchCache(code, config) {
-  console.log("# patchCached");
-  const cacheHandler = path9.join(config.paths.internalPackage, "cli", "cache-handler.mjs");
-  const patchedCode = code.replace(
-    "const { cacheHandler } = this.nextConfig;",
-    `const cacheHandler = null;
-CacheHandler = (await import('${cacheHandler}')).default;
-CacheHandler.maybeKVNamespace = process.env["${config.cache.kvBindingName}"];
-`
-  );
-  if (patchedCode === code) {
-    throw new Error("Cache patch not applied");
-  }
-  return patchedCode;
+  writeFileSync3(webpackRuntimeFile, updatedFileContent);
 }
 
 // src/cli/build/build-worker.ts
-var packageDistDir = path10.join(path10.dirname(fileURLToPath3(import.meta.url)), "..");
+var packageDistDir = path13.join(path13.dirname(fileURLToPath3(import.meta.url)), "..");
 async function buildWorker(config) {
   console.log(`\x1B[35m\u2699\uFE0F Copying files...
 \x1B[0m`);
   await cp(
-    path10.join(config.paths.dotNext, "static"),
-    path10.join(config.paths.builderOutput, "assets", "_next", "static"),
+    path13.join(config.paths.dotNext, "static"),
+    path13.join(config.paths.builderOutput, "assets", "_next", "static"),
     {
       recursive: true
     }
   );
-  const publicDir = path10.join(config.paths.nextApp, "public");
-  if (existsSync3(publicDir)) {
-    await cp(publicDir, path10.join(config.paths.builderOutput, "assets"), {
+  const publicDir = path13.join(config.paths.nextApp, "public");
+  if (existsSync5(publicDir)) {
+    await cp(publicDir, path13.join(config.paths.builderOutput, "assets"), {
       recursive: true
     });
   }
+  copyPrerenderedRoutes(config);
   copyPackageCliFiles(packageDistDir, config);
-  const templateDir = path10.join(config.paths.internalPackage, "cli", "templates");
-  const workerEntrypoint = path10.join(templateDir, "worker.ts");
-  const workerOutputFile = path10.join(config.paths.builderOutput, "index.mjs");
-  const nextConfigStr = readFileSync4(path10.join(config.paths.standaloneApp, "/server.js"), "utf8")?.match(
+  const templateDir = path13.join(config.paths.internalPackage, "cli", "templates");
+  const workerEntrypoint = path13.join(templateDir, "worker.ts");
+  const workerOutputFile = path13.join(config.paths.builderOutput, "index.mjs");
+  const nextConfigStr = readFileSync7(path13.join(config.paths.standaloneApp, "/server.js"), "utf8")?.match(
     /const nextConfig = ({.+?})\n/
   )?.[1] ?? {};
   console.log(`\x1B[35m\u2699\uFE0F Bundling the worker file...
@@ -7017,15 +7195,15 @@ async function buildWorker(config) {
       // 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": path10.join(templateDir, "shims", "empty.ts"),
+      "next/dist/compiled/ws": path13.join(templateDir, "shims", "empty.ts"),
       // 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": path10.join(templateDir, "shims", "empty.ts"),
+      "next/dist/compiled/edge-runtime": path13.join(templateDir, "shims", "empty.ts"),
       // `@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": path10.join(templateDir, "shims", "env.ts")
+      "@next/env": path13.join(templateDir, "shims", "env.ts")
     },
     define: {
       // config file used by Next.js, see: https://github.com/vercel/next.js/blob/68a7128/packages/next/src/build/utils.ts#L2137-L2139
@@ -7035,10 +7213,6 @@ async function buildWorker(config) {
       // 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 next.js server can run in minimal mode: https://github.com/vercel/next.js/blob/aa90fe9bb/packages/next/src/server/base-server.ts#L510-L511
-      // this avoids some extra (/problematic) `require` calls, such as here: https://github.com/vercel/next.js/blob/aa90fe9bb/packages/next/src/server/next-server.ts#L1259
-      // that's wht we enable it
-      "process.env.NEXT_PRIVATE_MINIMAL_MODE": "true",
       // Ask mhart if he can explain why the `define`s below are necessary
       "process.env.NEXT_RUNTIME": '"nodejs"',
       "process.env.NODE_ENV": '"production"',
@@ -7098,112 +7272,99 @@ async function updateWorkerBundledCode(workerOutputFile, config) {
   patchedCode = patchFindDir(patchedCode, config);
   patchedCode = inlineEvalManifest(patchedCode, config);
   patchedCode = patchCache(patchedCode, config);
+  patchedCode = inlineMiddlewareManifestRequire(patchedCode, config);
+  patchedCode = patchExceptionBubbling(patchedCode);
   await writeFile(workerOutputFile, patchedCode);
 }
 function createFixRequiresESBuildPlugin(templateDir) {
   return {
     name: "replaceRelative",
     setup(build3) {
-      build3.onResolve({ filter: /^\.\/require-hook$/ }, (args) => ({
-        path: path10.join(templateDir, "shims", "empty.ts")
+      build3.onResolve({ filter: /^\.\/require-hook$/ }, () => ({
+        path: path13.join(templateDir, "shims", "empty.ts")
       }));
-      build3.onResolve({ filter: /\.\/lib\/node-fs-methods$/ }, (args) => ({
-        path: path10.join(templateDir, "shims", "empty.ts")
+      build3.onResolve({ filter: /\.\/lib\/node-fs-methods$/ }, () => ({
+        path: path13.join(templateDir, "shims", "empty.ts")
       }));
     }
   };
 }
 
-// src/cli/config.ts
-import { readdirSync as readdirSync3, statSync as statSync2 } from "node:fs";
-import path11, { relative } from "node:path";
-var PACKAGE_NAME = "@opennextjs/cloudflare";
-var UserConfig = {
-  cache: {
-    bindingName: "NEXT_CACHE_WORKERS_KV"
-  }
-};
-function getConfig(appDir, outputDir2) {
-  const dotNext = path11.join(outputDir2, ".next");
-  const appPath = getNextjsApplicationPath(dotNext).replace(/\/$/, "");
-  const standaloneApp = path11.join(dotNext, "standalone", appPath);
-  const standaloneAppDotNext = path11.join(standaloneApp, ".next");
-  const standaloneAppServer = path11.join(standaloneAppDotNext, "server");
-  const nodeModules = path11.join(standaloneApp, "node_modules");
-  const internalPackage = path11.join(nodeModules, ...PACKAGE_NAME.split("/"));
-  return {
-    paths: {
-      nextApp: appDir,
-      builderOutput: outputDir2,
-      dotNext,
-      standaloneApp,
-      standaloneAppDotNext,
-      standaloneAppServer,
-      internalPackage
-    },
-    cache: {
-      kvBindingName: UserConfig.cache.bindingName
-    },
-    internalPackageName: PACKAGE_NAME
-  };
-}
-function containsDotNextDir(folder) {
-  try {
-    return statSync2(path11.join(folder, ".next")).isDirectory();
-  } catch (e) {
-    return false;
-  }
-}
-function getNextjsApplicationPath(dotNextDir) {
-  const serverPath = findServerParentPath(dotNextDir);
-  if (!serverPath) {
-    throw new Error(`Unexpected Error: no \`.next/server\` folder could be found in \`${serverPath}\``);
-  }
-  return relative(path11.join(dotNextDir, "standalone"), serverPath);
-}
-function findServerParentPath(parentPath) {
-  try {
-    if (statSync2(path11.join(parentPath, ".next", "server")).isDirectory()) {
-      return parentPath;
-    }
-  } catch {
-  }
-  const folders = readdirSync3(parentPath);
-  for (const folder of folders) {
-    const subFolder = path11.join(parentPath, folder);
-    if (statSync2(path11.join(parentPath, folder)).isDirectory()) {
-      const dirServerPath = findServerParentPath(subFolder);
-      if (dirServerPath) {
-        return dirServerPath;
-      }
-    }
-  }
-}
-
 // src/cli/build/index.ts
 import { cpSync as cpSync2 } from "node:fs";
-import path12 from "node:path";
+import path14 from "node:path";
+import { rm } from "node:fs/promises";
 async function build2(appDir, opts) {
   if (!opts.skipBuild) {
-    buildNextjsApp(appDir);
+    await buildNextjsApp(appDir);
   }
   if (!containsDotNextDir(appDir)) {
     throw new Error(`.next folder not found in ${appDir}`);
   }
-  const outputDir2 = path12.resolve(opts.outputDir ?? appDir, ".worker-next");
+  const outputDir2 = path14.resolve(opts.outputDir ?? appDir, ".worker-next");
   await cleanDirectory(outputDir2);
-  cpSync2(path12.join(appDir, ".next"), path12.join(outputDir2, ".next"), { recursive: true });
+  cpSync2(path14.join(appDir, ".next"), path14.join(outputDir2, ".next"), { recursive: true });
   const config = getConfig(appDir, outputDir2);
   await buildWorker(config);
 }
-async function cleanDirectory(path13) {
-  return await rm(path13, { recursive: true, force: true });
+async function cleanDirectory(path15) {
+  return await rm(path15, { recursive: true, force: true });
 }
 
 // src/cli/index.ts
+import { existsSync as existsSync6 } from "node:fs";
+
+// src/cli/args.ts
+import { mkdirSync as mkdirSync2, statSync as statSync3 } from "node:fs";
+import { parseArgs } from "node:util";
+import { resolve } from "node:path";
+function getArgs() {
+  const {
+    values: { skipBuild: skipBuild2, output }
+  } = parseArgs({
+    options: {
+      skipBuild: {
+        type: "boolean",
+        short: "s",
+        default: false
+      },
+      output: {
+        type: "string",
+        short: "o"
+      }
+    },
+    allowPositionals: false
+  });
+  const outputDir2 = output ? resolve(output) : void 0;
+  if (outputDir2) {
+    assertDirArg(outputDir2, "output", true);
+  }
+  return {
+    outputDir: outputDir2,
+    skipBuild: skipBuild2 || ["1", "true", "yes"].includes(String(process.env.SKIP_NEXT_APP_BUILD))
+  };
+}
+function assertDirArg(path15, argName, make) {
+  let dirStats;
+  try {
+    dirStats = statSync3(path15);
+  } catch {
+    if (!make) {
+      throw new Error(`Error: the provided${argName ? ` "${argName}"` : ""} input is not a valid path`);
+    }
+    mkdirSync2(path15);
+    return;
+  }
+  if (!dirStats.isDirectory()) {
+    throw new Error(`Error: the provided${argName ? ` "${argName}"` : ""} input is not a directory`);
+  }
+}
+
+// src/cli/index.ts
+import { resolve as resolve2 } from "node:path";
 var nextAppDir = resolve2(".");
 console.log(`Building the Next.js app in the current folder (${nextAppDir})`);
-if (!["js", "cjs", "mjs", "ts"].some((ext2) => existsSync4(`./next.config.${ext2}`))) {
+if (!["js", "cjs", "mjs", "ts"].some((ext2) => existsSync6(`./next.config.${ext2}`))) {
   throw new Error("Error: Not in a Next.js app project");
 }
 var { skipBuild, outputDir } = getArgs();