@opennextjs/aws 3.6.5 → 3.6.6

package/README.md

@@ -23,7 +23,7 @@ OpenNext takes the Next.js build output and converts it into packages that can b
 
 ## Features
 
-OpenNext aims to support all Next.js 14 features. Some features are work in progress. If you are running into any problems make sure to check the [docs](https://opennext.js.org/aws) first before you open a [new issue](/issues/new) or visit our [Discord](https://discord.gg/opennextjs) to let us know!
+OpenNext aims to support all Next.js 15 features. Some features are work in progress. If you are running into any problems make sure to check the [docs](https://opennext.js.org/aws) first before you open a [new issue](/issues/new) or visit our [Discord](https://discord.gg/opennextjs) to let us know!
 
 - [x] App & Pages Router
 - [x] API routes

package/dist/build/copyTracedFiles.js

@@ -1,5 +1,5 @@
 import url from "node:url";
-import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, statSync, symlinkSync, writeFileSync, } from "node:fs";
+import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, readlinkSync, statSync, symlinkSync, writeFileSync, } from "node:fs";
 import path from "node:path";
 import { loadAppPathsManifest, loadBuildId, loadConfig, loadFunctionsConfigManifest, loadMiddlewareManifest, loadPagesManifest, loadPrerenderManifest, } from "../adapters/config/util.js";
 import { getCrossPlatformPathRegex } from "../utils/regex.js";
@@ -223,15 +223,15 @@ File ${serverPath} does not exist
             copyFileSync(path.join(standaloneNextDir, filePath), path.join(outputNextDir, filePath));
         }
     };
+    const manifests = getManifests(standaloneNextDir);
+    const { config, prerenderManifest, pagesManifest } = manifests;
     // Get all the static files - Should be only for pages dir
     // Ideally we would filter only those that might get accessed in this specific functions
     // Maybe even move this to s3 directly
     if (hasPageDir) {
         // First we get truly static files - i.e. pages without getStaticProps
-        const staticFiles = Object.values(loadPagesManifest(standaloneNextDir));
+        const staticFiles = Object.values(pagesManifest);
         // Then we need to get all fallback: true dynamic routes html
-        const prerenderManifest = loadPrerenderManifest(standaloneNextDir);
-        const config = loadConfig(standaloneNextDir);
         const locales = config.i18n?.locales;
         Object.values(prerenderManifest.dynamicRoutes).forEach((route) => {
             if (typeof route.fallback === "string") {
@@ -249,10 +249,15 @@ File ${serverPath} does not exist
             .filter((file) => file.endsWith(".html"))
             .forEach((file) => copyStaticFile(`server/${file}`));
     }
+    // Copy .next/static/css from standalone to output dir
+    // needed for optimizeCss feature to work
+    if (config.experimental.optimizeCss) {
+        cpSync(path.join(standaloneNextDir, "static", "css"), path.join(outputNextDir, "static", "css"), { recursive: true });
+    }
     logger.debug("copyTracedFiles:", Date.now() - tsStart, "ms");
     return {
         tracedFiles,
         nodePackages,
-        manifests: getManifests(standaloneNextDir),
+        manifests,
     };
 }

package/dist/build/createAssets.js

@@ -62,44 +62,46 @@ export function createCacheAssets(options) {
     const packagePath = buildHelper.getPackagePath(options);
     const buildId = buildHelper.getBuildId(options);
     let useTagCache = false;
-    // Copy pages to cache folder
     const dotNextPath = path.join(appBuildOutputPath, ".next/standalone", packagePath);
-    const outputPath = path.join(outputDir, "cache", buildId);
-    [".next/server/pages", ".next/server/app"]
+    const outputCachePath = path.join(outputDir, "cache", buildId);
+    fs.mkdirSync(outputCachePath, { recursive: true });
+    const sourceDirs = [".next/server/pages", ".next/server/app"]
         .map((dir) => path.join(dotNextPath, dir))
-        .filter(fs.existsSync)
-        .forEach((dir) => fs.cpSync(dir, outputPath, { recursive: true }));
-    // Remove non-cache files
+        .filter(fs.existsSync);
     const htmlPages = buildHelper.getHtmlPages(dotNextPath);
-    buildHelper.removeFiles(outputPath, ({ relativePath }) => relativePath.endsWith(".js") ||
+    const isFileSkipped = (relativePath) => relativePath.endsWith(".js") ||
         relativePath.endsWith(".js.nft.json") ||
-        (relativePath.endsWith(".html") && htmlPages.has(relativePath)));
+        (relativePath.endsWith(".html") && htmlPages.has(relativePath));
     // Merge cache files into a single file
     const cacheFilesPath = {};
-    buildHelper.traverseFiles(outputPath, () => true, ({ absolutePath }) => {
-        const ext = path.extname(absolutePath);
-        switch (ext) {
-            case ".meta":
-            case ".html":
-            case ".json":
-            case ".body":
-            case ".rsc": {
-                const newFilePath = absolutePath
-                    .substring(0, absolutePath.length - ext.length)
-                    .replace(/\.prefetch$/, "")
-                    .concat(".cache");
-                cacheFilesPath[newFilePath] = {
-                    [ext.slice(1)]: absolutePath,
-                    ...cacheFilesPath[newFilePath],
-                };
-                break;
+    // Process each source directory
+    sourceDirs.forEach((sourceDir) => {
+        buildHelper.traverseFiles(sourceDir, ({ relativePath }) => !isFileSkipped(relativePath), ({ absolutePath, relativePath }) => {
+            const ext = path.extname(absolutePath);
+            switch (ext) {
+                case ".meta":
+                case ".html":
+                case ".json":
+                case ".body":
+                case ".rsc": {
+                    const newFilePath = path
+                        .join(outputCachePath, relativePath)
+                        .substring(0, path.join(outputCachePath, relativePath).length - ext.length)
+                        .replace(/\.prefetch$/, "")
+                        .concat(".cache");
+                    cacheFilesPath[newFilePath] = {
+                        [ext.slice(1)]: absolutePath,
+                        ...cacheFilesPath[newFilePath],
+                    };
+                    break;
+                }
+                case ".map":
+                    break;
+                default:
+                    logger.warn(`Unknown file extension: ${ext}`);
+                    break;
             }
-            case ".map":
-                break;
-            default:
-                logger.warn(`Unknown file extension: ${ext}`);
-                break;
-        }
+        });
     });
     // Generate cache file
     Object.entries(cacheFilesPath).forEach(([cacheFilePath, files]) => {
@@ -122,6 +124,8 @@ export function createCacheAssets(options) {
                     : "utf8")
                 : undefined,
         };
+        // Ensure directory exists before writing
+        fs.mkdirSync(path.dirname(cacheFilePath), { recursive: true });
         fs.writeFileSync(cacheFilePath, JSON.stringify(cacheFileContent));
     });
     // We need to traverse the cache to find every .meta file
@@ -149,36 +153,36 @@ export function createCacheAssets(options) {
     if (!options.config.dangerous?.disableTagCache) {
         // Compute dynamodb cache data
         // Traverse files inside cache to find all meta files and cache tags associated with them
-        buildHelper.traverseFiles(outputPath, ({ absolutePath }) => absolutePath.endsWith(".meta"), ({ absolutePath, relativePath }) => {
-            const fileContent = fs.readFileSync(absolutePath, "utf8");
-            const fileData = JSON.parse(fileContent);
-            if (fileData.headers?.["x-next-cache-tags"]) {
-                fileData.headers["x-next-cache-tags"]
-                    .split(",")
-                    .forEach((tag) => {
-                    // TODO: We should split the tag using getDerivedTags from next.js or maybe use an in house implementation
-                    metaFiles.push({
-                        tag: { S: path.posix.join(buildId, tag.trim()) },
-                        path: {
-                            S: path.posix.join(buildId, relativePath.replace(".meta", "")),
-                        },
-                        // We don't care about the revalidation time here, we just need to make sure it's there
-                        revalidatedAt: { N: "1" },
+        sourceDirs.forEach((sourceDir) => {
+            buildHelper.traverseFiles(sourceDir, ({ absolutePath, relativePath }) => absolutePath.endsWith(".meta") && !isFileSkipped(relativePath), ({ absolutePath, relativePath }) => {
+                const fileContent = fs.readFileSync(absolutePath, "utf8");
+                const fileData = JSON.parse(fileContent);
+                if (fileData.headers?.["x-next-cache-tags"]) {
+                    fileData.headers["x-next-cache-tags"]
+                        .split(",")
+                        .forEach((tag) => {
+                        // TODO: We should split the tag using getDerivedTags from next.js or maybe use an in house implementation
+                        metaFiles.push({
+                            tag: { S: path.posix.join(buildId, tag.trim()) },
+                            path: {
+                                S: path.posix.join(buildId, relativePath.replace(".meta", "")),
+                            },
+                            // We don't care about the revalidation time here, we just need to make sure it's there
+                            revalidatedAt: { N: "1" },
+                        });
                     });
-                });
-            }
+                }
+            });
         });
         if (metaFiles.length > 0) {
             useTagCache = true;
             const providerPath = path.join(outputDir, "dynamodb-provider");
-            //Copy open-next.config.mjs into the bundle
+            // Copy open-next.config.mjs into the bundle
             fs.mkdirSync(providerPath, { recursive: true });
             buildHelper.copyOpenNextConfig(options.buildDir, providerPath);
             // TODO: check if metafiles doesn't contain duplicates
             fs.writeFileSync(path.join(providerPath, "dynamodb-cache.json"), JSON.stringify(metaFiles));
         }
     }
-    // We need to remove files later because we need the metafiles for dynamodb tags cache
-    buildHelper.removeFiles(outputPath, ({ relativePath }) => !relativePath.endsWith(".cache"));
     return { useTagCache, metaFiles };
 }

package/dist/build/createServerBundle.js

@@ -126,7 +126,6 @@ async function generateBundle(name, options, fnOptions, codeCustomization) {
         patches.patchEnvVars,
         patches.patchBackgroundRevalidation,
         patches.patchUseCacheForISR,
-        patches.patchDropBabel,
         ...additionalCodePatches,
     ]);
     // Build Lambda code

package/dist/build/patch/patches/index.d.ts

@@ -3,4 +3,3 @@ export { patchNextServer } from "./patchNextServer.js";
 export { patchFetchCacheForISR, patchUnstableCacheForISR, patchUseCacheForISR, } from "./patchFetchCacheISR.js";
 export { patchFetchCacheSetMissingWaitUntil } from "./patchFetchCacheWaitUntil.js";
 export { patchBackgroundRevalidation } from "./patchBackgroundRevalidation.js";
-export { patchDropBabel } from "./dropBabel.js";

package/dist/build/patch/patches/index.js

@@ -3,4 +3,3 @@ export { patchNextServer } from "./patchNextServer.js";
 export { patchFetchCacheForISR, patchUnstableCacheForISR, patchUseCacheForISR, } from "./patchFetchCacheISR.js";
 export { patchFetchCacheSetMissingWaitUntil } from "./patchFetchCacheWaitUntil.js";
 export { patchBackgroundRevalidation } from "./patchBackgroundRevalidation.js";
-export { patchDropBabel } from "./dropBabel.js";

package/dist/build/patch/patches/patchNextServer.d.ts

@@ -1,5 +1,15 @@
 import type { CodePatcher } from "../codePatcher.js";
-export declare const minimalRule = "\nrule:\n  kind: member_expression\n  pattern: process.env.NEXT_MINIMAL\n  any:\n    - inside:\n        kind: parenthesized_expression\n        stopBy: end\n        inside:\n          kind: if_statement\n          any:\n            - inside:\n                kind: statement_block\n                inside:\n                  kind: method_definition\n                  any:\n                    - has: {kind: property_identifier, field: name, regex: runEdgeFunction}\n                    - has: {kind: property_identifier, field: name, regex: runMiddleware}\n                    - has: {kind: property_identifier, field: name, regex: imageOptimizer}\n            - has:\n                kind: statement_block\n                has:\n                  kind: expression_statement\n                  pattern: res.statusCode = 400;\nfix:\n  'true'\n";
-export declare const disablePreloadingRule = "\nrule:\n  kind: statement_block\n  inside:\n    kind: if_statement\n    any: \n      - has: \n          kind: member_expression\n          pattern: this.nextConfig.experimental.preloadEntriesOnStart\n          stopBy: end\n      - has: \n          kind: binary_expression\n          pattern: appDocumentPreloading === true\n          stopBy: end\nfix:\n  '{}'\n";
-export declare const removeMiddlewareManifestRule = "\nrule:\n  kind: statement_block\n  inside:\n    kind: method_definition\n    has:\n      kind: property_identifier\n      regex: getMiddlewareManifest\nfix:\n  '{return null;}'\n";
+export declare const disablePreloadingRule = "\nrule:\n  kind: statement_block\n  inside:\n    kind: if_statement\n    any:\n      - has:\n          kind: member_expression\n          pattern: this.nextConfig.experimental.preloadEntriesOnStart\n          stopBy: end\n      - has:\n          kind: binary_expression\n          pattern: appDocumentPreloading === true\n          stopBy: end\nfix:\n  '{}'\n";
+export declare const removeMiddlewareManifestRule = "\nrule:\n  kind: statement_block\n  inside:\n    kind: method_definition\n    has:\n      kind: property_identifier\n      regex: ^getMiddlewareManifest$\nfix:\n  '{return null;}'\n";
+/**
+ * Swaps the body for a throwing implementation
+ *
+ * @param methodName The name of the method
+ * @returns A rule to replace the body with a `throw`
+ */
+export declare function createEmptyBodyRule(methodName: string): string;
+/**
+ * Drops `require("./node-environment-extensions/error-inspect");`
+ */
+export declare const errorInspectRule = "\nrule:\n  pattern: require(\"./node-environment-extensions/error-inspect\");\nfix: |-\n  // Removed by OpenNext\n  // require(\"./node-environment-extensions/error-inspect\");\n";
 export declare const patchNextServer: CodePatcher;

package/dist/build/patch/patches/patchNextServer.js

@@ -1,51 +1,24 @@
+import { getCrossPlatformPathRegex } from "../../../utils/regex.js";
 import { createPatchCode } from "../astCodePatcher.js";
-// This rule will replace the `NEXT_MINIMAL` env variable with true in multiple places to avoid executing unwanted path (i.e. next middleware, edge functions and image optimization)
-export const minimalRule = `
-rule:
-  kind: member_expression
-  pattern: process.env.NEXT_MINIMAL
-  any:
-    - inside:
-        kind: parenthesized_expression
-        stopBy: end
-        inside:
-          kind: if_statement
-          any:
-            - inside:
-                kind: statement_block
-                inside:
-                  kind: method_definition
-                  any:
-                    - has: {kind: property_identifier, field: name, regex: runEdgeFunction}
-                    - has: {kind: property_identifier, field: name, regex: runMiddleware}
-                    - has: {kind: property_identifier, field: name, regex: imageOptimizer}
-            - has:
-                kind: statement_block
-                has:
-                  kind: expression_statement
-                  pattern: res.statusCode = 400;
-fix:
-  'true'
-`;
-// This rule will disable the background preloading of route done by NextServer by default during the creation of NextServer
+// Disable the background preloading of route done by NextServer by default during the creation of NextServer
 export const disablePreloadingRule = `
 rule:
   kind: statement_block
   inside:
     kind: if_statement
-    any: 
-      - has: 
+    any:
+      - has:
           kind: member_expression
           pattern: this.nextConfig.experimental.preloadEntriesOnStart
           stopBy: end
-      - has: 
+      - has:
           kind: binary_expression
           pattern: appDocumentPreloading === true
           stopBy: end
 fix:
   '{}'
 `;
-// This rule is mostly for splitted edge functions so that we don't try to match them on the other non edge functions
+// Mostly for splitted edge functions so that we don't try to match them on the other non edge functions
 export const removeMiddlewareManifestRule = `
 rule:
   kind: statement_block
@@ -53,39 +26,104 @@ rule:
     kind: method_definition
     has:
       kind: property_identifier
-      regex: getMiddlewareManifest
+      regex: ^getMiddlewareManifest$
 fix:
   '{return null;}'
 `;
+/**
+ * Swaps the body for a throwing implementation
+ *
+ * @param methodName The name of the method
+ * @returns A rule to replace the body with a `throw`
+ */
+export function createEmptyBodyRule(methodName) {
+    return `
+rule:
+  pattern:
+    selector: method_definition
+    context: "class { async ${methodName}($$$PARAMS) { $$$_ } }"
+fix: |-
+  async ${methodName}($$$PARAMS) {
+    throw new Error("${methodName} should not be called with OpenNext");
+  }
+`;
+}
+/**
+ * Drops `require("./node-environment-extensions/error-inspect");`
+ */
+export const errorInspectRule = `
+rule:
+  pattern: require("./node-environment-extensions/error-inspect");
+fix: |-
+  // Removed by OpenNext
+  // require("./node-environment-extensions/error-inspect");
+`;
+const pathFilter = getCrossPlatformPathRegex(String.raw `/next/dist/server/next-server\.js$`, {
+    escape: false,
+});
+/**
+ * Patches to avoid pulling babel (~4MB).
+ *
+ * Details:
+ * - empty `NextServer#runMiddleware` and `NextServer#runEdgeFunction` that are not used
+ * - drop `next/dist/server/node-environment-extensions/error-inspect.js`
+ */
+const babelPatches = [
+    // Empty the body of `NextServer#runMiddleware`
+    {
+        field: {
+            pathFilter,
+            contentFilter: /runMiddleware\(/,
+            patchCode: createPatchCode(createEmptyBodyRule("runMiddleware")),
+        },
+    },
+    // Empty the body of `NextServer#runEdgeFunction`
+    {
+        field: {
+            pathFilter,
+            contentFilter: /runEdgeFunction\(/,
+            patchCode: createPatchCode(createEmptyBodyRule("runEdgeFunction")),
+        },
+    },
+    // Drop `error-inspect` that pulls babel
+    {
+        field: {
+            pathFilter,
+            contentFilter: /error-inspect/,
+            patchCode: createPatchCode(errorInspectRule),
+        },
+    },
+];
 export const patchNextServer = {
     name: "patch-next-server",
     patches: [
-        // Skip executing next middleware, edge functions and image optimization inside NextServer
+        // Empty the body of `NextServer#imageOptimizer` - unused in OpenNext
         {
-            versions: ">=15.0.0",
             field: {
-                pathFilter: /next-server\.(js)$/,
-                contentFilter: /process\.env\.NEXT_MINIMAL/,
-                patchCode: createPatchCode(minimalRule),
+                pathFilter,
+                contentFilter: /imageOptimizer\(/,
+                patchCode: createPatchCode(createEmptyBodyRule("imageOptimizer")),
             },
         },
-        // Disable Next background preloading done at creation of `NetxServer`
+        // Disable Next background preloading done at creation of `NextServer`
         {
-            versions: ">=15.0.0",
+            versions: ">=14.0.0",
             field: {
-                pathFilter: /next-server\.(js)$/,
+                pathFilter,
                 contentFilter: /this\.nextConfig\.experimental\.preloadEntriesOnStart/,
                 patchCode: createPatchCode(disablePreloadingRule),
             },
         },
         // Don't match edge functions in `NextServer`
         {
-            versions: ">=15.0.0",
+            // Next 12 and some version of 13 use the bundled middleware/edge function
+            versions: ">=14.0.0",
             field: {
-                pathFilter: /next-server\.(js)$/,
+                pathFilter,
                 contentFilter: /getMiddlewareManifest/,
                 patchCode: createPatchCode(removeMiddlewareManifestRule),
             },
         },
+        ...babelPatches,
     ],
 };

package/dist/core/routing/cacheInterceptor.js

@@ -92,7 +92,8 @@ async function generateResult(event, localizedPath, cachedValue, lastModified) {
     const cacheControl = await computeCacheControl(localizedPath, body, event.headers.host, cachedValue.revalidate, lastModified);
     return {
         type: "core",
-        statusCode: 200,
+        // sometimes other status codes can be cached, like 404. For these cases, we should return the correct status code
+        statusCode: cachedValue.meta?.status ?? 200,
         body: toReadableStream(body, false),
         isBase64Encoded: false,
         headers: {

package/dist/core/routing/matcher.js

@@ -259,7 +259,8 @@ export function handleRedirects(event, redirects) {
 }
 export function fixDataPage(internalEvent, buildId) {
     const { rawPath, query } = internalEvent;
-    const dataPattern = `${NextConfig.basePath ?? ""}/_next/data/${buildId}`;
+    const basePath = NextConfig.basePath ?? "";
+    const dataPattern = `${basePath}/_next/data/${buildId}`;
     // Return 404 for data requests that don't match the buildId
     if (rawPath.startsWith("/_next/data") && !rawPath.startsWith(dataPattern)) {
         return {
@@ -273,9 +274,9 @@ export function fixDataPage(internalEvent, buildId) {
         };
     }
     if (rawPath.startsWith(dataPattern) && rawPath.endsWith(".json")) {
-        const newPath = rawPath
+        const newPath = `${basePath}${rawPath
             .slice(dataPattern.length, -".json".length)
-            .replace(/^\/index$/, "/");
+            .replace(/^\/index$/, "/")}`;
         query.__nextDataReq = "1";
         return {
             ...internalEvent,

package/dist/overrides/converters/edge.js

@@ -2,6 +2,8 @@ import { Buffer } from "node:buffer";
 import cookieParser from "cookie";
 import { parseSetCookieHeader } from "../../http/util";
 import { getQueryFromSearchParams } from "./utils.js";
+// https://fetch.spec.whatwg.org/#statuses
+const NULL_BODY_STATUSES = new Set([101, 103, 204, 205, 304]);
 const converter = {
     convertFrom: async (event) => {
         const url = new URL(event.url);
@@ -77,7 +79,11 @@ const converter = {
                 headers.set(key, value);
             }
         }
-        return new Response(result.body, {
+        // We should not return a body for statusCode's that doesn't allow bodies
+        const body = NULL_BODY_STATUSES.has(result.statusCode)
+            ? null
+            : result.body;
+        return new Response(body, {
             status: result.statusCode,
             headers,
         });

package/dist/types/next-types.d.ts

@@ -72,10 +72,12 @@ export interface NextConfig {
     experimental: {
         serverActions?: boolean;
         appDir?: boolean;
+        optimizeCss?: boolean;
     };
     images: ImageConfig;
     poweredByHeader?: boolean;
     serverExternalPackages?: string[];
+    deploymentId?: string;
 }
 export interface RouteDefinition {
     page: string;

package/package.json

@@ -3,7 +3,7 @@
     "access": "public"
   },
   "name": "@opennextjs/aws",
-  "version": "3.6.5",
+  "version": "3.6.6",
   "bin": {
     "open-next": "./dist/index.js"
   },

package/dist/build/patch/patches/dropBabel.d.ts

@@ -1,20 +0,0 @@
-/**
- * Patches to avoid pulling babel (~4MB).
- *
- * Details:
- * - empty `NextServer#runMiddleware` and `NextServer#runEdgeFunction` that are not used
- * - drop `next/dist/server/node-environment-extensions/error-inspect.js`
- */
-import type { CodePatcher } from "../codePatcher.js";
-export declare const patchDropBabel: CodePatcher;
-/**
- * Swaps the body for a throwing implementation
- *
- * @param methodName The name of the method
- * @returns A rule to replace the body with a `throw`
- */
-export declare function createEmptyBodyRule(methodName: string): string;
-/**
- * Drops `require("./node-environment-extensions/error-inspect");`
- */
-export declare const errorInspectRule = "\nrule:\n  pattern: require(\"./node-environment-extensions/error-inspect\");\nfix: |-\n  // Removed by OpenNext\n  // require(\"./node-environment-extensions/error-inspect\");\n";

package/dist/build/patch/patches/dropBabel.js

@@ -1,72 +0,0 @@
-/**
- * Patches to avoid pulling babel (~4MB).
- *
- * Details:
- * - empty `NextServer#runMiddleware` and `NextServer#runEdgeFunction` that are not used
- * - drop `next/dist/server/node-environment-extensions/error-inspect.js`
- */
-import { getCrossPlatformPathRegex } from "../../../utils/regex.js";
-import { patchCode } from "../astCodePatcher.js";
-export const patchDropBabel = {
-    name: "patch-drop-babel",
-    patches: [
-        // Empty the body of `NextServer#runMiddleware`
-        {
-            field: {
-                pathFilter: getCrossPlatformPathRegex(String.raw `/next/dist/server/next-server\.js$`, {
-                    escape: false,
-                }),
-                contentFilter: /runMiddleware\(/,
-                patchCode: async ({ code }) => patchCode(code, createEmptyBodyRule("runMiddleware")),
-            },
-        },
-        // Empty the body of `NextServer#runEdgeFunction`
-        {
-            field: {
-                pathFilter: getCrossPlatformPathRegex(String.raw `/next/dist/server/next-server\.js$`, {
-                    escape: false,
-                }),
-                contentFilter: /runEdgeFunction\(/,
-                patchCode: async ({ code }) => patchCode(code, createEmptyBodyRule("runEdgeFunction")),
-            },
-        },
-        // Drop `error-inspect` that pulls babel
-        {
-            field: {
-                pathFilter: getCrossPlatformPathRegex(String.raw `next/dist/server/node-environment\.js$`, {
-                    escape: false,
-                }),
-                contentFilter: /error-inspect/,
-                patchCode: async ({ code }) => patchCode(code, errorInspectRule),
-            },
-        },
-    ],
-};
-/**
- * Swaps the body for a throwing implementation
- *
- * @param methodName The name of the method
- * @returns A rule to replace the body with a `throw`
- */
-export function createEmptyBodyRule(methodName) {
-    return `
-rule:
-  pattern:
-    selector: method_definition
-    context: "class { async ${methodName}($$$PARAMS) { $$$_ } }"
-fix: |-
-  async ${methodName}($$$PARAMS) {
-    throw new Error("${methodName} should not be called with OpenNext");
-  }
-`;
-}
-/**
- * Drops `require("./node-environment-extensions/error-inspect");`
- */
-export const errorInspectRule = `
-rule:
-  pattern: require("./node-environment-extensions/error-inspect");
-fix: |-
-  // Removed by OpenNext
-  // require("./node-environment-extensions/error-inspect");
-`;