@opennextjs/cloudflare 0.2.1 → 0.3.0

package/dist/cli/build/patches/investigated/update-webpack-chunks-file/get-file-content-with-updated-webpack-f-require-code.js

@@ -0,0 +1,76 @@
+import * as ts from "ts-morph";
+/**
+ * Updates the function that in the unminified webpack runtime file appears as `__webpack_require__.f.require` which is a function that
+ * installs chunks by importing/requiring them at runtime.
+ *
+ * `__webpack_require__.f.require` example: https://github.com/webpack/webpack/blob/dae16ad11e/examples/module-worker/README.md?plain=1#L284-L304
+ *
+ * This function needs to be updated so that it requires chunks using the standard `require` function and not webpack's custom `require` logic
+ * which fails in the workerd runtime.
+ *
+ * @param sourceFile the webpack runtime file parsed with ts-morph (note: this gets side-effectfully updated)
+ * @param chunkInstallationIdentifiers the names of the `installedChunks` and `installChunk` variables
+ * @param chunks the identifiers of the chunks (found on the filesystem)
+ * @returns the content of the sourceFile but with the require function updated
+ */
+export async function getFileContentWithUpdatedWebpackFRequireCode(sourceFile, { installedChunks, installChunk }, chunks) {
+    const webpackFRequireFunction = sourceFile
+        .getDescendantsOfKind(ts.SyntaxKind.ArrowFunction)
+        .find((arrowFunction) => {
+        // the function is declared assigned in a binary expression, so let's check the binary expression
+        // to get more confidence that we've got the right arrow function
+        const binaryExpression = arrowFunction.getFirstAncestorByKind(ts.SyntaxKind.BinaryExpression);
+        if (!binaryExpression)
+            return false;
+        // the variable being assigned always ends with .f.require (even in unminified files)
+        const binaryExpressionLeft = binaryExpression.getLeft();
+        if (!binaryExpressionLeft.getText().endsWith(".f.require"))
+            return false;
+        // the binary expression is an assignment
+        const binaryExpressionOperator = binaryExpression.getOperatorToken();
+        if (binaryExpressionOperator.getText() !== "=")
+            return false;
+        // the right side of the expression is our arrow function
+        const binaryExpressionRight = binaryExpression.getRight();
+        if (binaryExpressionRight !== arrowFunction)
+            return false;
+        const arrowFunctionBody = arrowFunction.getBody();
+        if (!arrowFunctionBody.isKind(ts.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(ts.SyntaxKind.CallExpression)
+            .some((callExpression) => callExpression.getExpression().getText() === installChunk);
+        if (!callsInstallChunk)
+            return false;
+        const functionFirstParameterName = functionParameters[0]?.getName();
+        const accessesInstalledChunksUsingItsFirstParameter = arrowFunctionBody
+            .getDescendantsOfKind(ts.SyntaxKind.ElementAccessExpression)
+            .some((elementAccess) => {
+            return (elementAccess.getExpression().getText() === installedChunks &&
+                elementAccess.getArgumentExpression()?.getText() === functionFirstParameterName);
+        });
+        if (!accessesInstalledChunksUsingItsFirstParameter)
+            return false;
+        return true;
+    });
+    if (!webpackFRequireFunction) {
+        throw new Error("ERROR: unable to find the webpack f require function declaration");
+    }
+    const functionParameterNames = webpackFRequireFunction
+        .getParameters()
+        .map((parameter) => parameter.getName());
+    const chunkId = functionParameterNames[0];
+    const functionBody = webpackFRequireFunction.getBody();
+    functionBody.insertStatements(0, [
+        `if (${installedChunks}[${chunkId}]) return;`,
+        ...chunks.map((chunk) => `\nif(${chunkId} === ${chunk}) return ${installChunk}(require("./chunks/${chunk}.js"));`),
+    ]);
+    return sourceFile.print();
+}

package/dist/cli/build/patches/investigated/update-webpack-chunks-file/get-file-content-with-updated-webpack-f-require-code.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/build/patches/investigated/update-webpack-chunks-file/get-file-content-with-updated-webpack-f-require-code.test.js

@@ -0,0 +1,23 @@
+import { readFile } from "node:fs/promises";
+import { describe, expect, test } from "vitest";
+import { tsParseFile } from "../../../utils/index.js";
+import { getFileContentWithUpdatedWebpackFRequireCode } from "./get-file-content-with-updated-webpack-f-require-code";
+describe("getFileContentWithUpdatedWebpackFRequireCode", () => {
+    test("returns the updated content of the f.require function from unminified webpack runtime code", async () => {
+        const fileContent = await readFile(`${import.meta.dirname}/test-fixtures/unminified-webpacks-file.js`, "utf8");
+        const tsSourceFile = tsParseFile(fileContent);
+        const updatedFCode = await getFileContentWithUpdatedWebpackFRequireCode(tsSourceFile, { installChunk: "installChunk", installedChunks: "installedChunks" }, ["658"]);
+        expect(unstyleCode(updatedFCode)).toContain(`if (installedChunks[chunkId]) return;`);
+        expect(unstyleCode(updatedFCode)).toContain(`if (chunkId === 658) return installChunk(require("./chunks/658.js"));`);
+    });
+    test("returns the updated content of the f.require function from minified webpack runtime code", async () => {
+        const fileContent = await readFile(`${import.meta.dirname}/test-fixtures/minified-webpacks-file.js`, "utf8");
+        const tsSourceFile = tsParseFile(fileContent);
+        const updatedFCode = await getFileContentWithUpdatedWebpackFRequireCode(tsSourceFile, { installChunk: "r", installedChunks: "e" }, ["658"]);
+        expect(unstyleCode(updatedFCode)).toContain("if (e[o]) return;");
+        expect(unstyleCode(updatedFCode)).toContain(`if (o === 658) return r(require("./chunks/658.js"));`);
+    });
+});
+function unstyleCode(text) {
+    return text.replace(/\n\s+/g, "\n").replace(/\n/g, " ");
+}

package/dist/cli/build/patches/investigated/update-webpack-chunks-file/get-updated-webpack-chunks-file-content.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Updates the content of the webpack runtime file in a manner so that it doesn't perform runtime dynamic `require` calls which fail in our runtime.
+ *
+ * It does so by appropriately updating a function that in the unminified webpack runtime file appears as `__webpack_require__.f.require` which is
+ * the one that normally would cause dynamic requires to happen at runtime.
+ *
+ * `__webpack_require__.f.require` example: https://github.com/webpack/webpack/blob/dae16ad11e/examples/module-worker/README.md?plain=1#L284-L304
+ *
+ *
+ * @param fileContent the content of the webpack runtime file
+ * @param chunks the identifiers of the chunks (found on the filesystem)
+ * @returns the content of the webpack runtime file updated with our custom logic
+ */
+export declare function getUpdatedWebpackChunksFileContent(fileContent: string, chunks: string[]): Promise<string>;

package/dist/cli/build/patches/investigated/update-webpack-chunks-file/get-updated-webpack-chunks-file-content.js

@@ -0,0 +1,22 @@
+import { tsParseFile } from "../../../utils/index.js";
+import { getChunkInstallationIdentifiers } from "./get-chunk-installation-identifiers.js";
+import { getFileContentWithUpdatedWebpackFRequireCode } from "./get-file-content-with-updated-webpack-f-require-code.js";
+/**
+ * Updates the content of the webpack runtime file in a manner so that it doesn't perform runtime dynamic `require` calls which fail in our runtime.
+ *
+ * It does so by appropriately updating a function that in the unminified webpack runtime file appears as `__webpack_require__.f.require` which is
+ * the one that normally would cause dynamic requires to happen at runtime.
+ *
+ * `__webpack_require__.f.require` example: https://github.com/webpack/webpack/blob/dae16ad11e/examples/module-worker/README.md?plain=1#L284-L304
+ *
+ *
+ * @param fileContent the content of the webpack runtime file
+ * @param chunks the identifiers of the chunks (found on the filesystem)
+ * @returns the content of the webpack runtime file updated with our custom logic
+ */
+export async function getUpdatedWebpackChunksFileContent(fileContent, chunks) {
+    const tsSourceFile = tsParseFile(fileContent);
+    const chunkInstallationIdentifiers = await getChunkInstallationIdentifiers(tsSourceFile);
+    const updatedFileContent = getFileContentWithUpdatedWebpackFRequireCode(tsSourceFile, chunkInstallationIdentifiers, chunks);
+    return updatedFileContent;
+}

package/dist/cli/build/patches/investigated/update-webpack-chunks-file/get-updated-webpack-chunks-file-content.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/build/patches/investigated/update-webpack-chunks-file/get-updated-webpack-chunks-file-content.test.js

@@ -0,0 +1,15 @@
+import { readFile } from "node:fs/promises";
+import { describe, expect, test } from "vitest";
+import { getUpdatedWebpackChunksFileContent } from "./get-updated-webpack-chunks-file-content.js";
+describe("getUpdatedWebpackChunksFileContent", () => {
+    test("returns the updated content of a webpack runtime chunks unminified file", async () => {
+        const fileContent = await readFile(`${import.meta.dirname}/test-fixtures/unminified-webpacks-file.js`, "utf8");
+        const updatedContent = await getUpdatedWebpackChunksFileContent(fileContent, ["658"]);
+        expect(updatedContent).toMatchFileSnapshot("./test-snapshots/unminified-webpacks-file.js");
+    });
+    test("returns the updated content of a webpack runtime chunks minified file", async () => {
+        const fileContent = await readFile(`${import.meta.dirname}/test-fixtures/minified-webpacks-file.js`, "utf8");
+        const updatedContent = await getUpdatedWebpackChunksFileContent(fileContent, ["658"]);
+        expect(updatedContent).toMatchFileSnapshot("./test-snapshots/minified-webpacks-file.js");
+    });
+});

package/dist/cli/build/patches/investigated/update-webpack-chunks-file/index.d.ts

@@ -0,0 +1,8 @@
+import { Config } from "../../../../config.js";
+/**
+ * Fixes the webpack-runtime.js file by removing its webpack dynamic requires.
+ *
+ * This hack is particularly bad as it indicates that files inside the output directory still get a hold of files from the outside: `${nextjsAppPaths.standaloneAppServerDir}/webpack-runtime.js`
+ *    so this shows that not everything that's needed to deploy the application is in the output directory...
+ */
+export declare function updateWebpackChunksFile(config: Config): Promise<void>;

package/dist/cli/build/patches/investigated/update-webpack-chunks-file/index.js

@@ -0,0 +1,22 @@
+import { readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { getUpdatedWebpackChunksFileContent } from "./get-updated-webpack-chunks-file-content.js";
+/**
+ * Fixes the webpack-runtime.js file by removing its webpack dynamic requires.
+ *
+ * This hack is particularly bad as it indicates that files inside the output directory still get a hold of files from the outside: `${nextjsAppPaths.standaloneAppServerDir}/webpack-runtime.js`
+ *    so this shows that not everything that's needed to deploy the application is in the output directory...
+ */
+export async function updateWebpackChunksFile(config) {
+    console.log("# updateWebpackChunksFile");
+    const webpackRuntimeFile = join(config.paths.output.standaloneAppServer, "webpack-runtime.js");
+    const fileContent = readFileSync(webpackRuntimeFile, "utf-8");
+    const chunks = readdirSync(join(config.paths.output.standaloneAppServer, "chunks"))
+        .filter((chunk) => /^\d+\.js$/.test(chunk))
+        .map((chunk) => {
+        console.log(` - chunk ${chunk}`);
+        return chunk.replace(/\.js$/, "");
+    });
+    const updatedFileContent = await getUpdatedWebpackChunksFileContent(fileContent, chunks);
+    writeFileSync(webpackRuntimeFile, updatedFileContent);
+}

package/dist/cli/build/patches/to-investigate/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./inline-eval-manifest.js";
+export * from "./inline-middleware-manifest-require.js";
+export * from "./inline-next-require.js";
+export * from "./patch-exception-bubbling.js";
+export * from "./patch-find-dir.js";
+export * from "./patch-load-instrumentation-module.js";
+export * from "./patch-read-file.js";
+export * from "./wrangler-deps.js";

package/dist/cli/build/patches/to-investigate/index.js

@@ -0,0 +1,8 @@
+export * from "./inline-eval-manifest.js";
+export * from "./inline-middleware-manifest-require.js";
+export * from "./inline-next-require.js";
+export * from "./patch-exception-bubbling.js";
+export * from "./patch-find-dir.js";
+export * from "./patch-load-instrumentation-module.js";
+export * from "./patch-read-file.js";
+export * from "./wrangler-deps.js";

package/dist/cli/build/patches/to-investigate/inline-eval-manifest.d.ts

@@ -0,0 +1,9 @@
+import { Config } from "../../../config.js";
+/**
+ * `evalManifest` relies on readFileSync so we need to patch the function so that it instead returns the content of the manifest files
+ * which are known at build time
+ * (source: https://github.com/vercel/next.js/blob/b1e32c5d1f/packages/next/src/server/load-manifest.ts#L72)
+ * Note: we could/should probably just patch readFileSync here or something, but here the issue is that after the readFileSync call
+ * there is a vm `runInNewContext` call which we also don't support (source: https://github.com/vercel/next.js/blob/b1e32c5d1f/packages/next/src/server/load-manifest.ts#L88)
+ */
+export declare function inlineEvalManifest(code: string, config: Config): string;

package/dist/cli/build/patches/to-investigate/inline-eval-manifest.js

@@ -0,0 +1,32 @@
+import { join, posix } from "node:path";
+import { globSync } from "glob";
+import { normalizePath } from "../../utils/index.js";
+/**
+ * `evalManifest` relies on readFileSync so we need to patch the function so that it instead returns the content of the manifest files
+ * which are known at build time
+ * (source: https://github.com/vercel/next.js/blob/b1e32c5d1f/packages/next/src/server/load-manifest.ts#L72)
+ * Note: we could/should probably just patch readFileSync here or something, but here the issue is that after the readFileSync call
+ * there is a vm `runInNewContext` call which we also don't support (source: https://github.com/vercel/next.js/blob/b1e32c5d1f/packages/next/src/server/load-manifest.ts#L88)
+ */
+export function inlineEvalManifest(code, config) {
+    const manifestJss = globSync(normalizePath(join(config.paths.output.standaloneAppDotNext, "**", "*_client-reference-manifest.js"))).map((file) => normalizePath(file).replace(normalizePath(config.paths.output.standaloneApp) + posix.sep, ""));
+    return code.replace(/function evalManifest\((.+?), .+?\) {/, `$&
+		${manifestJss
+        .map((manifestJs) => `
+			  if ($1.endsWith("${manifestJs}")) {
+				require(${JSON.stringify(join(config.paths.output.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 evalManifest: " + $1);
+		`);
+}

package/dist/cli/build/patches/to-investigate/inline-middleware-manifest-require.d.ts

@@ -0,0 +1,6 @@
+import { Config } from "../../../config.js";
+/**
+ * Inlines the middleware manifest from the build output to prevent a dynamic require statement
+ * as they result in runtime failures.
+ */
+export declare function inlineMiddlewareManifestRequire(code: string, config: Config): string;

package/dist/cli/build/patches/to-investigate/inline-middleware-manifest-require.js

@@ -0,0 +1,13 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Inlines the middleware manifest from the build output to prevent a dynamic require statement
+ * as they result in runtime failures.
+ */
+export function inlineMiddlewareManifestRequire(code, config) {
+    const middlewareManifestPath = join(config.paths.output.standaloneAppServer, "middleware-manifest.json");
+    const middlewareManifest = existsSync(middlewareManifestPath)
+        ? JSON.parse(readFileSync(middlewareManifestPath, "utf-8"))
+        : {};
+    return code.replace("require(this.middlewareManifestPath)", JSON.stringify(middlewareManifest));
+}

package/dist/cli/build/patches/to-investigate/inline-next-require.d.ts

@@ -0,0 +1,6 @@
+import { Config } from "../../../config.js";
+/**
+ * The following avoid various Next.js specific files `require`d at runtime since we can just read
+ * and inline their content during build time
+ */
+export declare function inlineNextRequire(code: string, config: Config): string;

package/dist/cli/build/patches/to-investigate/inline-next-require.js

@@ -0,0 +1,36 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * The following avoid various Next.js specific files `require`d at runtime since we can just read
+ * and inline their content during build time
+ */
+export function inlineNextRequire(code, config) {
+    const pagesManifestFile = join(config.paths.output.standaloneAppServer, "pages-manifest.json");
+    const appPathsManifestFile = join(config.paths.output.standaloneAppServer, "app-paths-manifest.json");
+    const pagesManifestFiles = existsSync(pagesManifestFile)
+        ? Object.values(JSON.parse(readFileSync(pagesManifestFile, "utf-8"))).map((file) => ".next/server/" + file)
+        : [];
+    const appPathsManifestFiles = existsSync(appPathsManifestFile)
+        ? Object.values(JSON.parse(readFileSync(appPathsManifestFile, "utf-8"))).map((file) => ".next/server/" + file)
+        : [];
+    const allManifestFiles = pagesManifestFiles.concat(appPathsManifestFiles);
+    const htmlPages = allManifestFiles.filter((file) => file.endsWith(".html"));
+    const pageModules = allManifestFiles.filter((file) => file.endsWith(".js"));
+    return code.replace(/const pagePath = getPagePath\(.+?\);/, `$&
+    ${htmlPages
+        .map((htmlPage) => `
+          if (pagePath.endsWith("${htmlPage}")) {
+            return ${JSON.stringify(readFileSync(join(config.paths.output.standaloneApp, htmlPage), "utf-8"))};
+          }
+        `)
+        .join("\n")}
+    ${pageModules
+        .map((module) => `
+          if (pagePath.endsWith("${module}")) {
+            return require(${JSON.stringify(join(config.paths.output.standaloneApp, module))});
+          }
+        `)
+        .join("\n")}
+    throw new Error("Unknown pagePath: " + pagePath);
+    `);
+}

package/dist/cli/build/patches/to-investigate/patch-exception-bubbling.d.ts

@@ -0,0 +1,7 @@
+/**
+ * When using SSG and `dynamicParams = false`, Next.js throws a NoFallbackError. This error is
+ * bubbled up by default in Node.js servers, however this causes issues in the workerd with
+ * the current response handling and streaming implementation we have, and leads to hanging
+ * promises.
+ */
+export declare function patchExceptionBubbling(code: string): string;

package/dist/cli/build/patches/to-investigate/patch-exception-bubbling.js

@@ -0,0 +1,9 @@
+/**
+ * When using SSG and `dynamicParams = false`, Next.js throws a NoFallbackError. This error is
+ * bubbled up by default in Node.js servers, however this causes issues in the workerd with
+ * the current response handling and streaming implementation we have, and leads to hanging
+ * promises.
+ */
+export function patchExceptionBubbling(code) {
+    return code.replace('_nextBubbleNoFallback = "1"', "_nextBubbleNoFallback = undefined");
+}

package/dist/cli/build/patches/to-investigate/patch-find-dir.d.ts

@@ -0,0 +1,8 @@
+import { Config } from "../../../config.js";
+/**
+ * Here we patch `findDir` so that the next server can detect whether the `app` or `pages` directory exists
+ * (source: https://github.com/vercel/next.js/blob/ba995993/packages/next/src/lib/find-pages-dir.ts#L4-L13)
+ * (usage source: https://github.com/vercel/next.js/blob/ba995993/packages/next/src/server/next-server.ts#L450-L451)
+ * Note: `findDir` uses `fs.existsSync` under the hood, so patching that should be enough to make this work
+ */
+export declare function patchFindDir(code: string, config: Config): string;

package/dist/cli/build/patches/to-investigate/patch-find-dir.js

@@ -0,0 +1,21 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Here we patch `findDir` so that the next server can detect whether the `app` or `pages` directory exists
+ * (source: https://github.com/vercel/next.js/blob/ba995993/packages/next/src/lib/find-pages-dir.ts#L4-L13)
+ * (usage source: https://github.com/vercel/next.js/blob/ba995993/packages/next/src/server/next-server.ts#L450-L451)
+ * Note: `findDir` uses `fs.existsSync` under the hood, so patching that should be enough to make this work
+ */
+export function patchFindDir(code, config) {
+    return code.replace(/function findDir\((?<dir>dir\d*), (?<name>name\d*)\) {/, `function findDir($dir, $name) {
+			if ($dir.endsWith(".next/server")) {
+			if ($name === "app") {
+			  return ${existsSync(`${join(config.paths.output.standaloneAppServer, "app")}`)};
+	    }
+			if ($name === "pages") {
+			  return ${existsSync(`${join(config.paths.output.standaloneAppServer, "pages")}`)};
+	    }
+		}
+		throw new Error("Unknown findDir call: " + $dir + " " + $name);
+		`);
+}

package/dist/cli/build/patches/to-investigate/patch-load-instrumentation-module.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The `loadInstrumentationModule` method (source: https://github.com/vercel/next.js/blob/5b7833e3/packages/next/src/server/next-server.ts#L301)
+ * calls `module.findSourceMap` (https://nodejs.org/api/module.html#modulefindsourcemappath) which we haven't implemented causing a runtime error.
+ *
+ * To solve this issue this function gets all the `loadInstrumentationModule` declarations found in the file and removes all the statements
+ * from their bodies (making them no-op methods).
+ *
+ * Instrumentation is a Next.js feature for monitoring and logging (see: https://nextjs.org/docs/app/building-your-application/optimizing/instrumentation),
+ * the removal of this method's logic most likely breaks this feature (see: https://nextjs.org/docs/app/api-reference/file-conventions/instrumentation),
+ * so this function is likely temporary and something that we'll have to fix in the future.
+ *
+ * TODO: investigate and re-enable instrumentation (https://github.com/opennextjs/opennextjs-cloudflare/issues/171)
+ */
+export declare function patchLoadInstrumentationModule(code: string): string;

package/dist/cli/build/patches/to-investigate/patch-load-instrumentation-module.js

@@ -0,0 +1,34 @@
+import * as ts from "ts-morph";
+import { tsParseFile } from "../../utils/index.js";
+/**
+ * The `loadInstrumentationModule` method (source: https://github.com/vercel/next.js/blob/5b7833e3/packages/next/src/server/next-server.ts#L301)
+ * calls `module.findSourceMap` (https://nodejs.org/api/module.html#modulefindsourcemappath) which we haven't implemented causing a runtime error.
+ *
+ * To solve this issue this function gets all the `loadInstrumentationModule` declarations found in the file and removes all the statements
+ * from their bodies (making them no-op methods).
+ *
+ * Instrumentation is a Next.js feature for monitoring and logging (see: https://nextjs.org/docs/app/building-your-application/optimizing/instrumentation),
+ * the removal of this method's logic most likely breaks this feature (see: https://nextjs.org/docs/app/api-reference/file-conventions/instrumentation),
+ * so this function is likely temporary and something that we'll have to fix in the future.
+ *
+ * TODO: investigate and re-enable instrumentation (https://github.com/opennextjs/opennextjs-cloudflare/issues/171)
+ */
+export function patchLoadInstrumentationModule(code) {
+    const file = tsParseFile(code);
+    const loadInstrumentationModuleDeclarations = file
+        .getDescendantsOfKind(ts.SyntaxKind.MethodDeclaration)
+        .filter((methodDeclaration) => {
+        if (methodDeclaration.getName() !== "loadInstrumentationModule") {
+            return false;
+        }
+        const methodModifierKinds = methodDeclaration.getModifiers().map((modifier) => modifier.getKind());
+        if (methodModifierKinds.length !== 1 || methodModifierKinds[0] !== ts.SyntaxKind.AsyncKeyword) {
+            return false;
+        }
+        return true;
+    });
+    loadInstrumentationModuleDeclarations.forEach((loadInstrumentationModuleDeclaration) => {
+        loadInstrumentationModuleDeclaration.setBodyText("");
+    });
+    return file.print();
+}

package/dist/cli/build/patches/to-investigate/patch-read-file.d.ts

@@ -0,0 +1,3 @@
+import { Config } from "../../../config.js";
+export declare function patchBuildId(code: string, config: Config): string;
+export declare function patchLoadManifest(code: string, config: Config): string;

package/dist/cli/build/patches/to-investigate/patch-read-file.js

@@ -0,0 +1,29 @@
+import { readFileSync } from "node:fs";
+import { join, posix } from "node:path";
+import { globSync } from "glob";
+import { normalizePath } from "../../utils/index.js";
+export function patchBuildId(code, config) {
+    // The next-server code gets the buildId from the filesystem, resulting in a `[unenv] fs.readFileSync is not implemented yet!` error
+    // so we add an early return to the `getBuildId` function so that the `readyFileSync` is never encountered
+    // (source: https://github.com/vercel/next.js/blob/15aeb92efb34c09a36/packages/next/src/server/next-server.ts#L438-L451)
+    // Note: we could/should probably just patch readFileSync here or something!
+    return code.replace("getBuildId() {", `getBuildId() {
+      return ${JSON.stringify(readFileSync(join(config.paths.output.standaloneAppDotNext, "BUILD_ID"), "utf-8"))};
+    `);
+}
+export function patchLoadManifest(code, config) {
+    // Same as patchBuildId, the next-server code loads the manifests with `readFileSync` and we want to avoid that
+    // (source: https://github.com/vercel/next.js/blob/15aeb92e/packages/next/src/server/load-manifest.ts#L34-L56)
+    // Note: we could/should probably just patch readFileSync here or something!
+    const manifestJsons = globSync(normalizePath(join(config.paths.output.standaloneAppDotNext, "**", "*-manifest.json"))).map((file) => normalizePath(file).replace(normalizePath(config.paths.output.standaloneApp) + posix.sep, ""));
+    return code.replace(/function loadManifest\((.+?), .+?\) {/, `$&
+    ${manifestJsons
+        .map((manifestJson) => `
+          if ($1.endsWith("${manifestJson}")) {
+            return ${readFileSync(join(config.paths.output.standaloneApp, manifestJson), "utf-8")};
+          }
+        `)
+        .join("\n")}
+    throw new Error("Unknown loadManifest: " + $1);
+    `);
+}

package/dist/cli/build/patches/to-investigate/wrangler-deps.d.ts

@@ -0,0 +1,2 @@
+import { Config } from "../../../config.js";
+export declare function patchWranglerDeps(config: Config): void;

package/dist/cli/build/patches/to-investigate/wrangler-deps.js

@@ -0,0 +1,54 @@
+import { readFileSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+export function patchWranglerDeps(config) {
+    console.log("# patchWranglerDeps");
+    const distPath = getDistPath(config);
+    // Patch .next/standalone/node_modules/next/dist/compiled/next-server/pages.runtime.prod.js
+    //
+    // Remove the need for an alias in wrangler.toml:
+    //
+    // [alias]
+    // # critters is `require`d from `pages.runtime.prod.js` when running wrangler dev, so we need to stub it out
+    // "critters" = "./.next/standalone/node_modules/cf/templates/shims/empty.ts"
+    const pagesRuntimeFile = join(distPath, "compiled", "next-server", "pages.runtime.prod.js");
+    const patchedPagesRuntime = readFileSync(pagesRuntimeFile, "utf-8").replace(`e.exports=require("critters")`, `e.exports={}`);
+    writeFileSync(pagesRuntimeFile, patchedPagesRuntime);
+    // Patch .next/standalone/node_modules/next/dist/server/lib/trace/tracer.js
+    //
+    // Remove the need for an alias in wrangler.toml:
+    //
+    // [alias]
+    // # @opentelemetry/api is `require`d when running wrangler dev, so we need to stub it out
+    // # IMPORTANT: we shim @opentelemetry/api to the throwing shim so that it will throw right away, this is so that we throw inside the
+    // #            try block here: https://github.com/vercel/next.js/blob/9e8266a7/packages/next/src/server/lib/trace/tracer.ts#L27-L31
+    // #            causing the code to require the 'next/dist/compiled/@opentelemetry/api' module instead (which properly works)
+    // #"@opentelemetry/api" = "./.next/standalone/node_modules/cf/templates/shims/throw.ts"
+    const tracerFile = join(distPath, "server", "lib", "trace", "tracer.js");
+    const patchedTracer = readFileSync(tracerFile, "utf-8").replaceAll(/\w+\s*=\s*require\([^/]*opentelemetry.*\)/g, `throw new Error("@opentelemetry/api")`);
+    writeFileSync(tracerFile, patchedTracer);
+}
+/**
+ * Next.js saves the node_modules/next/dist directory in either the standaloneApp path or in the
+ * standaloneRoot path, this depends on where the next dependency is actually saved (
+ * https://github.com/vercel/next.js/blob/39e06c75/packages/next/src/build/webpack-config.ts#L103-L104
+ * ) and can depend on the package manager used, if it is using workspaces, etc...
+ *
+ * This function checks the two potential paths for the dist directory and returns the first that it finds,
+ * it throws an error if it can't find either
+ *
+ * @param config
+ * @returns the node_modules/next/dist directory path
+ */
+function getDistPath(config) {
+    for (const root of [config.paths.output.standaloneApp, config.paths.output.standaloneRoot]) {
+        try {
+            const distPath = join(root, "node_modules", "next", "dist");
+            if (statSync(distPath).isDirectory())
+                return distPath;
+        }
+        catch {
+            /* empty */
+        }
+    }
+    throw new Error("Unexpected error: unable to detect the node_modules/next/dist directory");
+}

package/dist/cli/build/utils/extract-project-env-vars.d.ts

@@ -0,0 +1,18 @@
+import type { BuildOptions } from "@opennextjs/aws/build/helper.js";
+/**
+ * Extracts the environment variables defined in various .env files for a project.
+ *
+ * The `NEXTJS_ENV` environment variable in `.dev.vars` determines the mode.
+ *
+ * Merged variables respect the following priority order.
+ * 1. `.env.{mode}.local`
+ * 2. `.env.local`
+ * 3. `.env.{mode}`
+ * 4. `.env`
+ *
+ * https://nextjs.org/docs/pages/building-your-application/configuring/environment-variables#environment-variable-load-order
+ *
+ * In a monorepo, the env files in an app's directory will take precedence over
+ * the env files at the root of the monorepo.
+ */
+export declare function extractProjectEnvVars(mode: string, { monorepoRoot, appPath }: BuildOptions): Record<string, string>;

package/dist/cli/build/utils/extract-project-env-vars.js

@@ -0,0 +1,32 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { parse } from "@dotenvx/dotenvx";
+function readEnvFile(filePath) {
+    if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) {
+        return parse(fs.readFileSync(filePath).toString());
+    }
+}
+/**
+ * Extracts the environment variables defined in various .env files for a project.
+ *
+ * The `NEXTJS_ENV` environment variable in `.dev.vars` determines the mode.
+ *
+ * Merged variables respect the following priority order.
+ * 1. `.env.{mode}.local`
+ * 2. `.env.local`
+ * 3. `.env.{mode}`
+ * 4. `.env`
+ *
+ * https://nextjs.org/docs/pages/building-your-application/configuring/environment-variables#environment-variable-load-order
+ *
+ * In a monorepo, the env files in an app's directory will take precedence over
+ * the env files at the root of the monorepo.
+ */
+export function extractProjectEnvVars(mode, { monorepoRoot, appPath }) {
+    return [".env", `.env.${mode}`, ".env.local", `.env.${mode}.local`]
+        .flatMap((fileName) => [
+        ...(monorepoRoot !== appPath ? [readEnvFile(path.join(monorepoRoot, fileName))] : []),
+        readEnvFile(path.join(appPath, fileName)),
+    ])
+        .reduce((acc, overrides) => ({ ...acc, ...overrides }), {});
+}

package/dist/cli/build/utils/extract-project-env-vars.spec.d.ts

@@ -0,0 +1 @@
+export {};