@vercel/next 4.2.0 → 4.2.1

package/dist/index.js

@@ -9408,7 +9408,6 @@ var import_buffer_crc32 = __toESM(require_buffer_crc32());
 var import_fs_extra3 = __toESM(require_lib2());
 var import_path2 = __toESM(require("path"));
 var import_semver = __toESM(require_semver());
-var import_zlib2 = __toESM(require("zlib"));
 var import_url = __toESM(require("url"));
 var import_module = require("module");
 var import_escape_string_regexp = __toESM(require_escape_string_regexp());
@@ -9485,9 +9484,8 @@ var import_path = require("path");
 var KIB = 1024;
 var MIB = 1024 * KIB;
 var EDGE_FUNCTION_SIZE_LIMIT = 4 * MIB;
-var MAX_UNCOMPRESSED_LAMBDA_SIZE = 250 * MIB;
-var LAMBDA_RESERVED_UNCOMPRESSED_SIZE = 2.5 * MIB;
-var LAMBDA_RESERVED_COMPRESSED_SIZE = 250 * KIB;
+var DEFAULT_MAX_UNCOMPRESSED_LAMBDA_SIZE = 250 * MIB;
+var LAMBDA_RESERVED_UNCOMPRESSED_SIZE = 25 * MIB;
 
 // src/edge-function-source/get-edge-function-source.ts
 var import_zlib = __toESM(require("zlib"));
@@ -9554,6 +9552,9 @@ async function validateSize(script, wasmFiles) {
 var require_ = (0, import_module.createRequire)(__filename);
 var RSC_CONTENT_TYPE = "x-component";
 var RSC_PREFETCH_SUFFIX = ".prefetch.rsc";
+var MAX_UNCOMPRESSED_LAMBDA_SIZE = !isNaN(
+  Number(process.env.MAX_UNCOMPRESSED_LAMBDA_SIZE)
+) ? Number(process.env.MAX_UNCOMPRESSED_LAMBDA_SIZE) : DEFAULT_MAX_UNCOMPRESSED_LAMBDA_SIZE;
 var TEST_DYNAMIC_ROUTE = /\/\[[^\/]+?\](?=\/|$)/;
 function isDynamicRoute(route) {
   route = route.startsWith("/") ? route : `/${route}`;
@@ -9764,6 +9765,14 @@ async function getDynamicRoutes({
             ),
             dest: route.dest?.replace(/($|\?)/, ".rsc$1")
           });
+          routes2.push({
+            ...route,
+            src: route.src.replace(
+              new RegExp((0, import_escape_string_regexp.default)("(?:/)?$")),
+              "(?:\\.action)(?:/)?$"
+            ),
+            dest: route.dest?.replace(/($|\?)/, ".action$1")
+          });
           routes2.push(route);
         }
         return routes2;
@@ -9937,19 +9946,6 @@ var collectTracedFiles = (baseDir, lstatResults, lstatSema, reasons, files) => a
   });
 };
 var ExperimentalTraceVersion = `9.0.4-canary.1`;
-var compressBuffer = (buf) => {
-  return new Promise((resolve, reject) => {
-    import_zlib2.default.deflateRaw(
-      buf,
-      { level: import_zlib2.default.constants.Z_BEST_COMPRESSION },
-      (err, compBuf) => {
-        if (err)
-          return reject(err);
-        resolve(compBuf);
-      }
-    );
-  });
-};
 async function createPseudoLayer(files) {
   const pseudoLayer = {};
   let pseudoLayerBytes = 0;
@@ -9964,11 +9960,9 @@ async function createPseudoLayer(files) {
       };
     } else {
       const origBuffer = await (0, import_build_utils.streamToBuffer)(file.toStream());
-      const compBuffer = await compressBuffer(origBuffer);
-      pseudoLayerBytes += compBuffer.byteLength;
+      pseudoLayerBytes += origBuffer.byteLength;
       pseudoLayer[fileName] = {
         file,
-        compBuffer,
         isSymlink: false,
         crc32: import_buffer_crc32.default.unsigned(origBuffer),
         uncompressedSize: origBuffer.byteLength
@@ -10376,7 +10370,6 @@ async function getPageLambdaGroups({
   tracedPseudoLayer,
   initialPseudoLayer,
   initialPseudoLayerUncompressed,
-  lambdaCompressedByteLimit,
   internalPages,
   pageExtensions,
   inversedAppPathManifest,
@@ -10410,22 +10403,18 @@ async function getPageLambdaGroups({
     let matchingGroup = experimentalAllowBundling ? void 0 : groups.find((group) => {
       const matches = group.maxDuration === opts.maxDuration && group.memory === opts.memory && group.isPrerenders === isPrerenderRoute && group.isExperimentalPPR === isExperimentalPPR;
       if (matches) {
-        let newTracedFilesSize = group.pseudoLayerBytes;
         let newTracedFilesUncompressedSize = group.pseudoLayerUncompressedBytes;
         for (const newPage of newPages) {
           Object.keys(pageTraces[newPage] || {}).map((file) => {
             if (!group.pseudoLayer[file]) {
               const item = tracedPseudoLayer[file];
-              newTracedFilesSize += item.compBuffer?.byteLength || 0;
               newTracedFilesUncompressedSize += item.uncompressedSize || 0;
             }
           });
-          newTracedFilesSize += compressedPages[newPage].compBuffer.byteLength;
           newTracedFilesUncompressedSize += compressedPages[newPage].uncompressedSize;
         }
         const underUncompressedLimit = newTracedFilesUncompressedSize < MAX_UNCOMPRESSED_LAMBDA_SIZE - LAMBDA_RESERVED_UNCOMPRESSED_SIZE;
-        const underCompressedLimit = newTracedFilesSize < lambdaCompressedByteLimit - LAMBDA_RESERVED_COMPRESSED_SIZE;
-        return underUncompressedLimit && underCompressedLimit;
+        return underUncompressedLimit;
       }
       return false;
     });
@@ -10448,31 +10437,24 @@ async function getPageLambdaGroups({
     for (const newPage of newPages) {
       Object.keys(pageTraces[newPage] || {}).map((file) => {
         const pseudoItem = tracedPseudoLayer[file];
-        const compressedSize = pseudoItem?.compBuffer?.byteLength || 0;
         if (!matchingGroup.pseudoLayer[file]) {
           matchingGroup.pseudoLayer[file] = pseudoItem;
-          matchingGroup.pseudoLayerBytes += compressedSize;
           matchingGroup.pseudoLayerUncompressedBytes += pseudoItem.uncompressedSize || 0;
         }
       });
-      matchingGroup.pseudoLayerBytes += compressedPages[newPage].compBuffer.byteLength;
       matchingGroup.pseudoLayerUncompressedBytes += compressedPages[newPage].uncompressedSize;
     }
   }
   return groups;
 }
-var outputFunctionFileSizeInfo = (pages, pseudoLayer, pseudoLayerBytes, pseudoLayerUncompressedBytes, compressedPages) => {
+var outputFunctionFileSizeInfo = (pages, pseudoLayer, pseudoLayerUncompressedBytes, compressedPages) => {
   const exceededLimitOutput = [];
   console.log(
     `Serverless Function's page${pages.length === 1 ? "" : "s"}: ${pages.join(
       ", "
     )}`
   );
-  exceededLimitOutput.push([
-    "Large Dependencies",
-    "Uncompressed size",
-    "Compressed size"
-  ]);
+  exceededLimitOutput.push(["Large Dependencies", "Uncompressed size"]);
   const dependencies = {};
   for (const fileKey of Object.keys(pseudoLayer)) {
     if (!pseudoLayer[fileKey].isSymlink) {
@@ -10480,17 +10462,14 @@ var outputFunctionFileSizeInfo = (pages, pseudoLayer, pseudoLayerBytes, pseudoLa
       const depKey = fileKey.split("/").slice(0, 3).join("/");
       if (!dependencies[depKey]) {
         dependencies[depKey] = {
-          compressed: 0,
           uncompressed: 0
         };
       }
-      dependencies[depKey].compressed += fileItem.compBuffer.byteLength;
       dependencies[depKey].uncompressed += fileItem.uncompressedSize;
     }
   }
   for (const page of pages) {
     dependencies[`pages/${page}`] = {
-      compressed: compressedPages[page].compBuffer.byteLength,
       uncompressed: compressedPages[page].uncompressedSize
     };
   }
@@ -10498,51 +10477,45 @@ var outputFunctionFileSizeInfo = (pages, pseudoLayer, pseudoLayerBytes, pseudoLa
   Object.keys(dependencies).sort((a, b) => {
     const aDep = dependencies[a];
     const bDep = dependencies[b];
-    if (aDep.compressed > bDep.compressed) {
+    if (aDep.uncompressed > bDep.uncompressed) {
       return -1;
     }
-    if (aDep.compressed < bDep.compressed) {
+    if (aDep.uncompressed < bDep.uncompressed) {
       return 1;
     }
     return 0;
   }).forEach((depKey) => {
     const dep = dependencies[depKey];
-    if (dep.compressed < 100 * KIB && dep.uncompressed < 500 * KIB) {
+    if (dep.uncompressed < 500 * KIB) {
       return;
     }
-    exceededLimitOutput.push([
-      depKey,
-      prettyBytes(dep.uncompressed),
-      prettyBytes(dep.compressed)
-    ]);
+    exceededLimitOutput.push([depKey, prettyBytes(dep.uncompressed)]);
     numLargeDependencies += 1;
   });
   if (numLargeDependencies === 0) {
     exceededLimitOutput.push([
-      "No large dependencies found (> 100KB compressed)"
+      "No large dependencies found (> 500KB compressed)"
     ]);
   }
   exceededLimitOutput.push([]);
   exceededLimitOutput.push([
     "All dependencies",
-    prettyBytes(pseudoLayerUncompressedBytes),
-    prettyBytes(pseudoLayerBytes)
+    prettyBytes(pseudoLayerUncompressedBytes)
   ]);
   console.log(
     (0, import_text_table.default)(exceededLimitOutput, {
-      align: ["l", "r", "r"]
+      align: ["l", "r"]
     })
   );
 };
-var detectLambdaLimitExceeding = async (lambdaGroups, compressedSizeLimit, compressedPages) => {
-  const COMPRESSED_SIZE_LIMIT_CLOSE = compressedSizeLimit - 5 * MIB;
+var detectLambdaLimitExceeding = async (lambdaGroups, compressedPages) => {
   const UNCOMPRESSED_SIZE_LIMIT_CLOSE = MAX_UNCOMPRESSED_LAMBDA_SIZE - 5 * MIB;
   let numExceededLimit = 0;
   let numCloseToLimit = 0;
   let loggedHeadInfo = false;
   const filteredGroups = lambdaGroups.filter((group) => {
-    const exceededLimit = group.pseudoLayerBytes > compressedSizeLimit || group.pseudoLayerUncompressedBytes > MAX_UNCOMPRESSED_LAMBDA_SIZE;
-    const closeToLimit = group.pseudoLayerBytes > COMPRESSED_SIZE_LIMIT_CLOSE || group.pseudoLayerUncompressedBytes > UNCOMPRESSED_SIZE_LIMIT_CLOSE;
+    const exceededLimit = group.pseudoLayerUncompressedBytes > MAX_UNCOMPRESSED_LAMBDA_SIZE;
+    const closeToLimit = group.pseudoLayerUncompressedBytes > UNCOMPRESSED_SIZE_LIMIT_CLOSE;
     if (closeToLimit || exceededLimit || (0, import_build_utils.getPlatformEnv)("BUILDER_DEBUG") || process.env.NEXT_DEBUG_FUNCTION_SIZE) {
       if (exceededLimit) {
         numExceededLimit += 1;
@@ -10558,8 +10531,6 @@ var detectLambdaLimitExceeding = async (lambdaGroups, compressedSizeLimit, compr
       if (numExceededLimit || numCloseToLimit) {
         console.log(
           `Warning: Max serverless function size of ${prettyBytes(
-            compressedSizeLimit
-          )} compressed or ${prettyBytes(
             MAX_UNCOMPRESSED_LAMBDA_SIZE
           )} uncompressed${numExceededLimit ? "" : " almost"} reached`
         );
@@ -10571,7 +10542,6 @@ var detectLambdaLimitExceeding = async (lambdaGroups, compressedSizeLimit, compr
     outputFunctionFileSizeInfo(
       group.pages,
       group.pseudoLayer,
-      group.pseudoLayerBytes,
       group.pseudoLayerUncompressedBytes,
       compressedPages
     );
@@ -12019,6 +11989,7 @@ var CORRECT_NOT_FOUND_ROUTES_VERSION = "v12.0.1";
 var CORRECT_MIDDLEWARE_ORDER_VERSION = "v12.1.7-canary.29";
 var NEXT_DATA_MIDDLEWARE_RESOLVING_VERSION = "v12.1.7-canary.33";
 var EMPTY_ALLOW_QUERY_FOR_PRERENDERED_VERSION = "v12.2.0";
+var ACTION_OUTPUT_SUPPORT_VERSION = "v14.2.2";
 var CORRECTED_MANIFESTS_VERSION = "v12.2.0";
 var PRELOAD_CHUNKS = {
   APP_ROUTER_PAGES: [
@@ -12081,7 +12052,6 @@ async function serverBuild({
   omittedPrerenderRoutes,
   trailingSlashRedirects,
   isCorrectLocaleAPIRoutes,
-  lambdaCompressedByteLimit,
   requiredServerFilesManifest,
   variantsManifest,
   experimentalPPRRoutes
@@ -12099,6 +12069,10 @@ async function serverBuild({
     nextVersion,
     EMPTY_ALLOW_QUERY_FOR_PRERENDERED_VERSION
   );
+  const hasActionOutputSupport = import_semver3.default.gte(
+    nextVersion,
+    ACTION_OUTPUT_SUPPORT_VERSION
+  );
   const projectDir = requiredServerFilesManifest.relativeAppDir ? import_path4.default.join(baseDir, requiredServerFilesManifest.relativeAppDir) : requiredServerFilesManifest.appDir || entryPath;
   const inversedAppPathManifest = {};
   if (appPathRoutesManifest) {
@@ -12423,23 +12397,20 @@ async function serverBuild({
         2
       )
     );
-    if (initialPseudoLayer.pseudoLayerBytes > lambdaCompressedByteLimit || uncompressedInitialSize > MAX_UNCOMPRESSED_LAMBDA_SIZE) {
+    if (uncompressedInitialSize > MAX_UNCOMPRESSED_LAMBDA_SIZE) {
       console.log(
         `Warning: Max serverless function size of ${(0, import_pretty_bytes3.default)(
-          lambdaCompressedByteLimit
-        )} compressed or ${(0, import_pretty_bytes3.default)(
           MAX_UNCOMPRESSED_LAMBDA_SIZE
         )} uncompressed reached`
       );
       outputFunctionFileSizeInfo(
         [],
         initialPseudoLayer.pseudoLayer,
-        initialPseudoLayer.pseudoLayerBytes,
         uncompressedInitialSize,
         {}
       );
       throw new import_build_utils2.NowBuildError({
-        message: `Required files read using Node.js fs library and node_modules exceed max lambda size of ${lambdaCompressedByteLimit} bytes`,
+        message: `Required files read using Node.js fs library and node_modules exceed max lambda size of ${MAX_UNCOMPRESSED_LAMBDA_SIZE} bytes`,
         code: "NEXT_REQUIRED_FILES_LIMIT",
         link: "https://vercel.com/docs/platform/limits#serverless-function-size"
       });
@@ -12601,7 +12572,6 @@ async function serverBuild({
       experimentalPPRRoutes: void 0,
       tracedPseudoLayer: tracedPseudoLayer.pseudoLayer,
       initialPseudoLayer,
-      lambdaCompressedByteLimit,
       initialPseudoLayerUncompressed: uncompressedInitialSize,
       internalPages,
       pageExtensions
@@ -12621,7 +12591,6 @@ async function serverBuild({
       experimentalPPRRoutes,
       tracedPseudoLayer: tracedPseudoLayer.pseudoLayer,
       initialPseudoLayer,
-      lambdaCompressedByteLimit,
       initialPseudoLayerUncompressed: uncompressedInitialSize,
       internalPages,
       pageExtensions,
@@ -12639,17 +12608,24 @@ async function serverBuild({
       experimentalPPRRoutes: void 0,
       tracedPseudoLayer: tracedPseudoLayer.pseudoLayer,
       initialPseudoLayer,
-      lambdaCompressedByteLimit,
       initialPseudoLayerUncompressed: uncompressedInitialSize,
       internalPages,
       pageExtensions,
       inversedAppPathManifest
     });
+    const appRouterStreamingPrerenderLambdaGroups = [];
     for (const group of appRouterLambdaGroups) {
       if (!group.isPrerenders || group.isExperimentalPPR) {
         group.isStreaming = true;
       }
       group.isAppRouter = true;
+      if (hasActionOutputSupport && group.isPrerenders && !group.isStreaming && !group.isExperimentalPPR) {
+        appRouterStreamingPrerenderLambdaGroups.push({
+          ...group,
+          isActionPrerender: true,
+          isStreaming: true
+        });
+      }
     }
     for (const group of appRouteHandlersLambdaGroups) {
       if (!group.isPrerenders) {
@@ -12670,7 +12646,6 @@ async function serverBuild({
       tracedPseudoLayer: tracedPseudoLayer.pseudoLayer,
       initialPseudoLayer,
       initialPseudoLayerUncompressed: uncompressedInitialSize,
-      lambdaCompressedByteLimit,
       internalPages,
       pageExtensions
     });
@@ -12698,6 +12673,12 @@ async function serverBuild({
             pseudoLayerBytes: group.pseudoLayerBytes,
             uncompressedLayerBytes: group.pseudoLayerUncompressedBytes
           })),
+          appRouterStreamingPrerenderLambdaGroups: appRouterStreamingPrerenderLambdaGroups.map((group) => ({
+            pages: group.pages,
+            isPrerender: group.isPrerenders,
+            pseudoLayerBytes: group.pseudoLayerBytes,
+            uncompressedLayerBytes: group.pseudoLayerUncompressedBytes
+          })),
           appRouteHandlersLambdaGroups: appRouteHandlersLambdaGroups.map(
             (group) => ({
               pages: group.pages,
@@ -12715,17 +12696,20 @@ async function serverBuild({
     const combinedGroups = [
       ...pageLambdaGroups,
       ...appRouterLambdaGroups,
+      ...appRouterStreamingPrerenderLambdaGroups,
       ...apiLambdaGroups,
       ...appRouteHandlersLambdaGroups
     ];
-    await detectLambdaLimitExceeding(
-      combinedGroups,
-      lambdaCompressedByteLimit,
-      compressedPages
-    );
+    await detectLambdaLimitExceeding(combinedGroups, compressedPages);
+    const appNotFoundTraces = pageTraces["_not-found.js"];
+    const appNotFoundPsuedoLayer = appNotFoundTraces && await createPseudoLayer(appNotFoundTraces);
     for (const group of combinedGroups) {
       const groupPageFiles = {};
-      for (const page of [...group.pages, ...internalPages]) {
+      for (const page of [
+        ...group.pages,
+        ...internalPages,
+        ...group.isAppRouter && appNotFoundTraces ? ["_not-found.js"] : []
+      ]) {
         const pageFileName = import_path4.default.normalize(
           import_path4.default.relative(baseDir, lambdaPages[page].fsPath)
         );
@@ -12831,6 +12815,9 @@ async function serverBuild({
         nextVersion,
         experimentalAllowBundling
       };
+      if (group.isAppRouter && appNotFoundPsuedoLayer) {
+        options.layers.push(appNotFoundPsuedoLayer.pseudoLayer);
+      }
       const lambda = await createLambdaFromPseudoLayers(options);
       const isPPR = experimental.ppr && group.isAppRouter && !group.isAppRouteHandler;
       let revalidate;
@@ -12856,6 +12843,9 @@ async function serverBuild({
           });
         }
         let outputName = import_path4.default.posix.join(entryDirectory, pageName);
+        if (group.isActionPrerender) {
+          outputName = `${outputName}.action`;
+        }
         if (isPPR) {
           if (!revalidate) {
             throw new Error("Invariant: PPR lambda isn't set");
@@ -13395,6 +13385,70 @@ async function serverBuild({
             override: true
           }
         ] : [],
+        ...hasActionOutputSupport ? [
+          // Create rewrites for streaming prerenders (.action routes)
+          // This contains separate rewrites for each possible "has" (action header, or content-type)
+          // Also includes separate handling for index routes which should match to /index.action.
+          // This follows the same pattern as the rewrites for .rsc files.
+          {
+            src: `^${import_path4.default.posix.join("/", entryDirectory, "/")}`,
+            dest: import_path4.default.posix.join("/", entryDirectory, "/index.action"),
+            has: [
+              {
+                type: "header",
+                key: "next-action"
+              }
+            ],
+            continue: true,
+            override: true
+          },
+          {
+            src: `^${import_path4.default.posix.join("/", entryDirectory, "/")}`,
+            dest: import_path4.default.posix.join("/", entryDirectory, "/index.action"),
+            has: [
+              {
+                type: "header",
+                key: "content-type",
+                value: "multipart/form-data;.*"
+              }
+            ],
+            continue: true,
+            override: true
+          },
+          {
+            src: `^${import_path4.default.posix.join(
+              "/",
+              entryDirectory,
+              "/((?!.+\\.action).+?)(?:/)?$"
+            )}`,
+            dest: import_path4.default.posix.join("/", entryDirectory, "/$1.action"),
+            has: [
+              {
+                type: "header",
+                key: "next-action"
+              }
+            ],
+            continue: true,
+            override: true
+          },
+          {
+            src: `^${import_path4.default.posix.join(
+              "/",
+              entryDirectory,
+              "/((?!.+\\.action).+?)(?:/)?$"
+            )}`,
+            dest: import_path4.default.posix.join("/", entryDirectory, "/$1.action"),
+            has: [
+              {
+                type: "header",
+                key: "content-type",
+                value: "multipart/form-data;.*"
+              }
+            ],
+            continue: true,
+            override: true
+          }
+        ] : [],
         {
           src: `^${import_path4.default.posix.join("/", entryDirectory, "/")}`,
           has: [
@@ -13827,7 +13881,6 @@ var build = async ({
   meta = {}
 }) => {
   validateEntrypoint(entrypoint);
-  const lambdaCompressedByteLimit = config.maxLambdaSize || 50 * MIB;
   let entryDirectory = import_path5.default.dirname(entrypoint);
   let entryPath = import_path5.default.join(workPath, entryDirectory);
   if (config.rootDirectory) {
@@ -13932,6 +13985,20 @@ var build = async ({
   } else {
     await (0, import_build_utils3.runNpmInstall)(entryPath, [], spawnOpts, meta, nodeVersion);
   }
+  if (spawnOpts.env.VERCEL_ANALYTICS_ID) {
+    (0, import_build_utils3.debug)("Found VERCEL_ANALYTICS_ID in environment");
+    const version2 = await (0, import_build_utils3.getInstalledPackageVersion)(
+      "@vercel/speed-insights",
+      entryPath
+    );
+    if (version2) {
+      delete spawnOpts.env.VERCEL_ANALYTICS_ID;
+      delete process.env.VERCEL_ANALYTICS_ID;
+      (0, import_build_utils3.debug)(
+        "@vercel/speed-insights is installed, removing VERCEL_ANALYTICS_ID from environment"
+      );
+    }
+  }
   const nextVersion = getRealNextVersion(entryPath);
   if (!nextVersion) {
     throw new import_build_utils3.NowBuildError({
@@ -14686,7 +14753,6 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         escapedBuildId,
         outputDirectory,
         trailingSlashRedirects,
-        lambdaCompressedByteLimit,
         requiredServerFilesManifest,
         privateOutputs,
         hasIsr404Page,
@@ -14858,7 +14924,6 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         tracedPseudoLayer: tracedPseudoLayer?.pseudoLayer || {},
         initialPseudoLayer: { pseudoLayer: {}, pseudoLayerBytes: 0 },
         initialPseudoLayerUncompressed: 0,
-        lambdaCompressedByteLimit,
         // internal pages are already referenced in traces for serverless
         // like builds
         internalPages: [],
@@ -14875,7 +14940,6 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         tracedPseudoLayer: tracedPseudoLayer?.pseudoLayer || {},
         initialPseudoLayer: { pseudoLayer: {}, pseudoLayerBytes: 0 },
         initialPseudoLayerUncompressed: 0,
-        lambdaCompressedByteLimit,
         internalPages: [],
         experimentalPPRRoutes: void 0
       });
@@ -14906,7 +14970,6 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       ];
       await detectLambdaLimitExceeding(
         combinedInitialLambdaGroups,
-        lambdaCompressedByteLimit,
         compressedPages
       );
       let apiLambdaGroupIndex = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/next",
-  "version": "4.2.0",
+  "version": "4.2.1",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/next-js",