@vercel/next 4.0.7 → 4.0.9

package/dist/index.js

@@ -837,7 +837,7 @@ var require_lib = __commonJS({
     function defaultInit() {
       return "1";
     }
-    var Sema4 = class {
+    var Sema3 = class {
       constructor(nr, { initFn = defaultInit, pauseFn, resumeFn, capacity = 10 } = {}) {
         if (isFn(pauseFn) !== isFn(resumeFn)) {
           throw new Error("pauseFn and resumeFn must be both set for pausing");
@@ -893,9 +893,9 @@ var require_lib = __commonJS({
         return this.waiting.length;
       }
     };
-    exports.Sema = Sema4;
+    exports.Sema = Sema3;
     function RateLimit(rps, { timeUnit = 1e3, uniformDistribution = false } = {}) {
-      const sema = new Sema4(uniformDistribution ? 1 : rps);
+      const sema = new Sema3(uniformDistribution ? 1 : rps);
       const delay = uniformDistribution ? timeUnit / rps : timeUnit;
       return async function rl() {
         await sema.acquire();
@@ -5870,313 +5870,6 @@ var require_semver = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/buffer-crc32@0.2.13/node_modules/buffer-crc32/index.js
-var require_buffer_crc32 = __commonJS({
-  "../../node_modules/.pnpm/buffer-crc32@0.2.13/node_modules/buffer-crc32/index.js"(exports, module2) {
-    var Buffer2 = require("buffer").Buffer;
-    var CRC_TABLE = [
-      0,
-      1996959894,
-      3993919788,
-      2567524794,
-      124634137,
-      1886057615,
-      3915621685,
-      2657392035,
-      249268274,
-      2044508324,
-      3772115230,
-      2547177864,
-      162941995,
-      2125561021,
-      3887607047,
-      2428444049,
-      498536548,
-      1789927666,
-      4089016648,
-      2227061214,
-      450548861,
-      1843258603,
-      4107580753,
-      2211677639,
-      325883990,
-      1684777152,
-      4251122042,
-      2321926636,
-      335633487,
-      1661365465,
-      4195302755,
-      2366115317,
-      997073096,
-      1281953886,
-      3579855332,
-      2724688242,
-      1006888145,
-      1258607687,
-      3524101629,
-      2768942443,
-      901097722,
-      1119000684,
-      3686517206,
-      2898065728,
-      853044451,
-      1172266101,
-      3705015759,
-      2882616665,
-      651767980,
-      1373503546,
-      3369554304,
-      3218104598,
-      565507253,
-      1454621731,
-      3485111705,
-      3099436303,
-      671266974,
-      1594198024,
-      3322730930,
-      2970347812,
-      795835527,
-      1483230225,
-      3244367275,
-      3060149565,
-      1994146192,
-      31158534,
-      2563907772,
-      4023717930,
-      1907459465,
-      112637215,
-      2680153253,
-      3904427059,
-      2013776290,
-      251722036,
-      2517215374,
-      3775830040,
-      2137656763,
-      141376813,
-      2439277719,
-      3865271297,
-      1802195444,
-      476864866,
-      2238001368,
-      4066508878,
-      1812370925,
-      453092731,
-      2181625025,
-      4111451223,
-      1706088902,
-      314042704,
-      2344532202,
-      4240017532,
-      1658658271,
-      366619977,
-      2362670323,
-      4224994405,
-      1303535960,
-      984961486,
-      2747007092,
-      3569037538,
-      1256170817,
-      1037604311,
-      2765210733,
-      3554079995,
-      1131014506,
-      879679996,
-      2909243462,
-      3663771856,
-      1141124467,
-      855842277,
-      2852801631,
-      3708648649,
-      1342533948,
-      654459306,
-      3188396048,
-      3373015174,
-      1466479909,
-      544179635,
-      3110523913,
-      3462522015,
-      1591671054,
-      702138776,
-      2966460450,
-      3352799412,
-      1504918807,
-      783551873,
-      3082640443,
-      3233442989,
-      3988292384,
-      2596254646,
-      62317068,
-      1957810842,
-      3939845945,
-      2647816111,
-      81470997,
-      1943803523,
-      3814918930,
-      2489596804,
-      225274430,
-      2053790376,
-      3826175755,
-      2466906013,
-      167816743,
-      2097651377,
-      4027552580,
-      2265490386,
-      503444072,
-      1762050814,
-      4150417245,
-      2154129355,
-      426522225,
-      1852507879,
-      4275313526,
-      2312317920,
-      282753626,
-      1742555852,
-      4189708143,
-      2394877945,
-      397917763,
-      1622183637,
-      3604390888,
-      2714866558,
-      953729732,
-      1340076626,
-      3518719985,
-      2797360999,
-      1068828381,
-      1219638859,
-      3624741850,
-      2936675148,
-      906185462,
-      1090812512,
-      3747672003,
-      2825379669,
-      829329135,
-      1181335161,
-      3412177804,
-      3160834842,
-      628085408,
-      1382605366,
-      3423369109,
-      3138078467,
-      570562233,
-      1426400815,
-      3317316542,
-      2998733608,
-      733239954,
-      1555261956,
-      3268935591,
-      3050360625,
-      752459403,
-      1541320221,
-      2607071920,
-      3965973030,
-      1969922972,
-      40735498,
-      2617837225,
-      3943577151,
-      1913087877,
-      83908371,
-      2512341634,
-      3803740692,
-      2075208622,
-      213261112,
-      2463272603,
-      3855990285,
-      2094854071,
-      198958881,
-      2262029012,
-      4057260610,
-      1759359992,
-      534414190,
-      2176718541,
-      4139329115,
-      1873836001,
-      414664567,
-      2282248934,
-      4279200368,
-      1711684554,
-      285281116,
-      2405801727,
-      4167216745,
-      1634467795,
-      376229701,
-      2685067896,
-      3608007406,
-      1308918612,
-      956543938,
-      2808555105,
-      3495958263,
-      1231636301,
-      1047427035,
-      2932959818,
-      3654703836,
-      1088359270,
-      936918e3,
-      2847714899,
-      3736837829,
-      1202900863,
-      817233897,
-      3183342108,
-      3401237130,
-      1404277552,
-      615818150,
-      3134207493,
-      3453421203,
-      1423857449,
-      601450431,
-      3009837614,
-      3294710456,
-      1567103746,
-      711928724,
-      3020668471,
-      3272380065,
-      1510334235,
-      755167117
-    ];
-    if (typeof Int32Array !== "undefined") {
-      CRC_TABLE = new Int32Array(CRC_TABLE);
-    }
-    function ensureBuffer(input) {
-      if (Buffer2.isBuffer(input)) {
-        return input;
-      }
-      var hasNewBufferAPI = typeof Buffer2.alloc === "function" && typeof Buffer2.from === "function";
-      if (typeof input === "number") {
-        return hasNewBufferAPI ? Buffer2.alloc(input) : new Buffer2(input);
-      } else if (typeof input === "string") {
-        return hasNewBufferAPI ? Buffer2.from(input) : new Buffer2(input);
-      } else {
-        throw new Error("input must be buffer, number, or string, received " + typeof input);
-      }
-    }
-    function bufferizeInt(num) {
-      var tmp = ensureBuffer(4);
-      tmp.writeInt32BE(num, 0);
-      return tmp;
-    }
-    function _crc32(buf, previous) {
-      buf = ensureBuffer(buf);
-      if (Buffer2.isBuffer(previous)) {
-        previous = previous.readUInt32BE(0);
-      }
-      var crc = ~~previous ^ -1;
-      for (var n = 0; n < buf.length; n++) {
-        crc = CRC_TABLE[(crc ^ buf[n]) & 255] ^ crc >>> 8;
-      }
-      return crc ^ -1;
-    }
-    function crc322() {
-      return bufferizeInt(_crc32.apply(null, arguments));
-    }
-    crc322.signed = function() {
-      return _crc32.apply(null, arguments);
-    };
-    crc322.unsigned = function() {
-      return _crc32.apply(null, arguments) >>> 0;
-    };
-    module2.exports = crc322;
-  }
-});
-
 // ../../node_modules/.pnpm/text-table@0.2.0/node_modules/text-table/index.js
 var require_text_table = __commonJS({
   "../../node_modules/.pnpm/text-table@0.2.0/node_modules/text-table/index.js"(exports, module2) {
@@ -9385,7 +9078,7 @@ module.exports = __toCommonJS(src_exports);
 var import_build_utils3 = require("@vercel/build-utils");
 var import_superstatic = __toESM(require_superstatic());
 var import_nft2 = require("@vercel/nft");
-var import_async_sema3 = __toESM(require_lib());
+var import_async_sema2 = __toESM(require_lib());
 var import_escape_string_regexp3 = __toESM(require_escape_string_regexp());
 var import_find_up = __toESM(require_find_up());
 var import_fs_extra6 = __toESM(require_lib2());
@@ -9400,12 +9093,9 @@ var import_semver2 = __toESM(require_semver());
 
 // src/utils.ts
 var import_build_utils = require("@vercel/build-utils");
-var import_async_sema = __toESM(require_lib());
-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());
@@ -9484,7 +9174,6 @@ 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;
 
 // src/edge-function-source/get-edge-function-source.ts
 var import_zlib = __toESM(require("zlib"));
@@ -9498,7 +9187,7 @@ var prettyBytes = (n) => (0, import_bytes.default)(n, { unitSeparator: " " });
 var import_get_nextjs_edge_function = __toESM(require_get_nextjs_edge_function());
 var gzip = (0, import_util.promisify)(import_zlib.default.gzip);
 async function getNextjsEdgeFunctionSource(filePaths, params, outputDir, wasm) {
-  const chunks = new import_webpack_sources2.ConcatSource(raw(`let _ENTRIES = {};`));
+  const chunks = new import_webpack_sources2.ConcatSource(raw(`globalThis._ENTRIES = {};`));
   for (const filePath of filePaths) {
     const fullFilePath = (0, import_path.join)(outputDir, filePath);
     const content = await (0, import_fs_extra2.readFile)(fullFilePath, "utf8");
@@ -9893,7 +9582,7 @@ function getFilesMapFromReasons(fileList, reasons, ignoreFn) {
   }
   return parentFilesMap;
 }
-var collectTracedFiles = (baseDir, lstatResults, lstatSema, reasons, files) => async (file) => {
+var collectTracedFiles = async (file, baseDir, lstatResults, lstatSema, reasons, files) => {
   const reason = reasons.get(file);
   if (reason && reason.type.includes("initial")) {
     return;
@@ -9909,47 +9598,42 @@ 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 = {};
+async function createPseudoLayer({
+  files,
+  lstatSema,
+  lstatResults
+}) {
   let pseudoLayerBytes = 0;
-  for (const fileName of Object.keys(files)) {
-    const file = files[fileName];
-    if ((0, import_build_utils.isSymbolicLink)(file.mode)) {
-      const symlinkTarget = await import_fs_extra3.default.readlink(file.fsPath);
-      pseudoLayer[fileName] = {
-        file,
-        isSymlink: true,
-        symlinkTarget
-      };
-    } else {
-      const origBuffer = await (0, import_build_utils.streamToBuffer)(file.toStream());
-      const compBuffer = await compressBuffer(origBuffer);
-      pseudoLayerBytes += compBuffer.byteLength;
-      pseudoLayer[fileName] = {
-        file,
-        compBuffer,
-        isSymlink: false,
-        crc32: import_buffer_crc32.default.unsigned(origBuffer),
-        uncompressedSize: origBuffer.byteLength
-      };
-    }
-  }
+  const pseudoLayer = {};
+  const fileNames = Object.keys(files);
+  await Promise.all(
+    fileNames.map(async (fileName) => {
+      await lstatSema.acquire();
+      const file = files[fileName];
+      if ((0, import_build_utils.isSymbolicLink)(file.mode)) {
+        const symlinkTarget = await import_fs_extra3.default.readlink(file.fsPath);
+        pseudoLayer[fileName] = {
+          file,
+          isSymlink: true,
+          symlinkTarget
+        };
+      } else {
+        if (!lstatResults[file.fsPath]) {
+          lstatResults[file.fsPath] = lstatSema.acquire().then(() => (0, import_fs_extra3.lstat)(file.fsPath)).finally(() => lstatSema.release());
+        }
+        const { size } = await lstatResults[file.fsPath];
+        pseudoLayerBytes += size;
+        pseudoLayer[fileName] = {
+          file,
+          isSymlink: false,
+          uncompressedSize: size
+        };
+      }
+      lstatSema.release();
+    })
+  );
   return { pseudoLayer, pseudoLayerBytes };
 }
-var createLambdaSema = new import_async_sema.Sema(1);
 async function createLambdaFromPseudoLayers({
   files: baseFiles,
   layers,
@@ -9957,7 +9641,6 @@ async function createLambdaFromPseudoLayers({
   nextVersion,
   ...lambdaOptions
 }) {
-  await createLambdaSema.acquire();
   const files = {};
   const addedFiles = /* @__PURE__ */ new Set();
   for (const layer of layers) {
@@ -9978,7 +9661,6 @@ async function createLambdaFromPseudoLayers({
     files[fileName] = file;
     addedFiles.add(fileName);
   }
-  createLambdaSema.release();
   return new import_build_utils.NodejsLambda({
     ...lambdaOptions,
     ...isStreaming ? {
@@ -10323,8 +10005,6 @@ async function getPageLambdaGroups({
   compressedPages,
   tracedPseudoLayer,
   initialPseudoLayer,
-  initialPseudoLayerUncompressed,
-  lambdaCompressedByteLimit,
   internalPages,
   pageExtensions
 }) {
@@ -10352,22 +10032,18 @@ async function getPageLambdaGroups({
     let matchingGroup = groups.find((group) => {
       const matches = group.maxDuration === opts.maxDuration && group.memory === opts.memory && group.isPrerenders === isPrerenderRoute;
       if (matches) {
-        let newTracedFilesSize = group.pseudoLayerBytes;
-        let newTracedFilesUncompressedSize = group.pseudoLayerUncompressedBytes;
+        let newTracedFilesUncompressedSize = group.pseudoLayerBytes;
         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;
     });
@@ -10380,7 +10056,6 @@ async function getPageLambdaGroups({
         isPrerenders: isPrerenderRoute,
         isApiLambda: !!isApiPage(page),
         pseudoLayerBytes: initialPseudoLayer.pseudoLayerBytes,
-        pseudoLayerUncompressedBytes: initialPseudoLayerUncompressed,
         pseudoLayer: Object.assign({}, initialPseudoLayer.pseudoLayer)
       };
       groups.push(newGroup);
@@ -10389,31 +10064,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 += pseudoItem.uncompressedSize || 0;
         }
       });
-      matchingGroup.pseudoLayerBytes += compressedPages[newPage].compBuffer.byteLength;
-      matchingGroup.pseudoLayerUncompressedBytes += compressedPages[newPage].uncompressedSize;
+      matchingGroup.pseudoLayerBytes += compressedPages[newPage].uncompressedSize;
     }
   }
   return groups;
 }
-var outputFunctionFileSizeInfo = (pages, pseudoLayer, pseudoLayerBytes, pseudoLayerUncompressedBytes, compressedPages) => {
+var outputFunctionFileSizeInfo = (pages, pseudoLayer, pseudoLayerBytes, 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) {
@@ -10421,17 +10089,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
     };
   }
@@ -10439,23 +10104,19 @@ 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) {
@@ -10464,26 +10125,21 @@ var outputFunctionFileSizeInfo = (pages, pseudoLayer, pseudoLayerBytes, pseudoLa
     ]);
   }
   exceededLimitOutput.push([]);
-  exceededLimitOutput.push([
-    "All dependencies",
-    prettyBytes(pseudoLayerUncompressedBytes),
-    prettyBytes(pseudoLayerBytes)
-  ]);
+  exceededLimitOutput.push(["All dependencies", prettyBytes(pseudoLayerBytes)]);
   console.log(
     (0, import_text_table.default)(exceededLimitOutput, {
       align: ["l", "r", "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.pseudoLayerBytes > MAX_UNCOMPRESSED_LAMBDA_SIZE;
+    const closeToLimit = group.pseudoLayerBytes > UNCOMPRESSED_SIZE_LIMIT_CLOSE;
     if (closeToLimit || exceededLimit || (0, import_build_utils.getPlatformEnv)("BUILDER_DEBUG") || process.env.NEXT_DEBUG_FUNCTION_SIZE) {
       if (exceededLimit) {
         numExceededLimit += 1;
@@ -10499,8 +10155,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`
         );
@@ -10513,7 +10167,6 @@ var detectLambdaLimitExceeding = async (lambdaGroups, compressedSizeLimit, compr
       group.pages,
       group.pseudoLayer,
       group.pseudoLayerBytes,
-      group.pseudoLayerUncompressedBytes,
       compressedPages
     );
   }
@@ -11001,9 +10654,12 @@ function normalizeEdgeFunctionPath(shortPath, appPathRoutesManifest) {
   if (shortPath.startsWith("app/") && (shortPath.endsWith("/page") || shortPath.endsWith("/route") || shortPath === "app/_not-found")) {
     const ogRoute = shortPath.replace(/^app\//, "/");
     shortPath = (appPathRoutesManifest[ogRoute] || shortPath.replace(/(^|\/)(page|route)$/, "")).replace(/^\//, "");
-    if (!shortPath || shortPath === "/") {
-      shortPath = "index";
-    }
+  }
+  if (shortPath.startsWith("pages/")) {
+    shortPath = shortPath.replace(/^pages\//, "");
+  }
+  if (!shortPath || shortPath === "/") {
+    shortPath = "index";
   }
   return shortPath;
 }
@@ -11746,7 +11402,7 @@ var legacy_versions_default = [
 // src/server-build.ts
 var import_path4 = __toESM(require("path"));
 var import_semver3 = __toESM(require_semver());
-var import_async_sema2 = __toESM(require_lib());
+var import_async_sema = __toESM(require_lib());
 var import_build_utils2 = require("@vercel/build-utils");
 var import_nft = require("@vercel/nft");
 var import_resolve_from = __toESM(require_resolve_from());
@@ -11798,7 +11454,6 @@ async function serverBuild({
   omittedPrerenderRoutes,
   trailingSlashRedirects,
   isCorrectLocaleAPIRoutes,
-  lambdaCompressedByteLimit,
   requiredServerFilesManifest,
   variantsManifest
 }) {
@@ -11866,7 +11521,7 @@ async function serverBuild({
   if (!hasStatic500 && i18n) {
     hasStatic500 = !!staticPages[import_path4.default.posix.join(entryDirectory, i18n.defaultLocale, "500")];
   }
-  const lstatSema = new import_async_sema2.Sema(25);
+  const lstatSema = new import_async_sema.Sema(25);
   const lstatResults = {};
   const nonLambdaSsgPages = /* @__PURE__ */ new Set();
   Object.keys(prerenderManifest.staticRoutes).forEach((route) => {
@@ -11991,18 +11646,23 @@ async function serverBuild({
     }
     (0, import_build_utils2.debug)("collecting initial Next.js server files");
     await Promise.all(
-      initialFileList.map(
-        collectTracedFiles(
+      initialFileList.map(async (file) => {
+        await collectTracedFiles(
+          file,
           baseDir,
           lstatResults,
           lstatSema,
           initialFileReasons,
           initialTracedFiles
-        )
-      )
+        );
+      })
     );
     (0, import_build_utils2.debug)("creating initial pseudo layer");
-    const initialPseudoLayer = await createPseudoLayer(initialTracedFiles);
+    const initialPseudoLayer = await createPseudoLayer({
+      files: initialTracedFiles,
+      lstatResults,
+      lstatSema
+    });
     console.timeEnd(initialTracingLabel);
     const lambdaCreationLabel = "Created all serverless functions in";
     console.time(lambdaCreationLabel);
@@ -12010,13 +11670,13 @@ async function serverBuild({
     const nonApiPages = [];
     const appRouterPages = [];
     const appRouteHandlers = [];
-    lambdaPageKeys.forEach((page) => {
+    for (const page of lambdaPageKeys) {
       if (internalPages.includes(page) && page !== "404.js" && !(page === "_error.js" && !(static404Page || lambdaPages["404.js"]))) {
-        return;
+        continue;
       }
       const pathname = page.replace(/\.js$/, "");
       if (nonLambdaSsgPages.has(pathname)) {
-        return;
+        continue;
       }
       const normalizedPathname = normalizePage(pathname);
       if (isDynamicRoute(normalizedPathname)) {
@@ -12033,7 +11693,7 @@ async function serverBuild({
       } else {
         nonApiPages.push(page);
       }
-    });
+    }
     const requiredFiles = {};
     requiredFiles[import_path4.default.relative(baseDir, nextServerFile)] = new import_build_utils2.FileFsRef({
       mode: (await import_fs_extra5.default.lstat(nextServerFile)).mode,
@@ -12099,33 +11759,28 @@ async function serverBuild({
         });
       })
     );
-    const requiredFilesLayer = await createPseudoLayer(requiredFiles);
+    const requiredFilesLayer = await createPseudoLayer({
+      files: requiredFiles,
+      lstatResults,
+      lstatSema
+    });
     Object.assign(
       initialPseudoLayer.pseudoLayer,
       requiredFilesLayer.pseudoLayer
     );
     initialPseudoLayer.pseudoLayerBytes += requiredFilesLayer.pseudoLayerBytes;
-    const uncompressedInitialSize = Object.keys(
-      initialPseudoLayer.pseudoLayer
-    ).reduce((prev, cur) => {
-      const file = initialPseudoLayer.pseudoLayer[cur];
-      return prev + file.uncompressedSize || 0;
-    }, 0);
     (0, import_build_utils2.debug)(
       JSON.stringify(
         {
-          uncompressedInitialSize,
-          compressedInitialSize: initialPseudoLayer.pseudoLayerBytes
+          initializeSizeUncompressed: initialPseudoLayer.pseudoLayerBytes
         },
         null,
         2
       )
     );
-    if (initialPseudoLayer.pseudoLayerBytes > lambdaCompressedByteLimit || uncompressedInitialSize > MAX_UNCOMPRESSED_LAMBDA_SIZE) {
+    if (initialPseudoLayer.pseudoLayerBytes > 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`
       );
@@ -12133,11 +11788,10 @@ async function serverBuild({
         [],
         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"
       });
@@ -12161,12 +11815,12 @@ async function serverBuild({
       useBundledServer ? BUNDLED_SERVER_NEXT_PATH : `${getNextServerPath(nextVersion)}/next-server.js`
     );
     const appLauncher = launcher.replace(
-      "// pre-next-server-target",
+      "// @preserve pre-next-server-target",
       `process.env.__NEXT_PRIVATE_PREBUNDLED_REACT = "${requiredServerFilesManifest.config?.experimental?.serverActions ? "experimental" : "next"}"`
     );
     if (entryDirectory !== "." && import_path4.default.posix.join("/", entryDirectory) !== routesManifest.basePath) {
       launcher = launcher.replace(
-        "// entryDirectory handler",
+        "// @preserve entryDirectory handler",
         `req.url = req.url.replace(/^${import_path4.default.posix.join("/", entryDirectory).replace(/\//g, "\\/")}/, '')`
       );
     }
@@ -12188,17 +11842,22 @@ async function serverBuild({
       }
       return originalPagePath;
     };
-    const getBuildTraceFile = (page) => {
-      return pageBuildTraces[page + ".nft.json"] || appBuildTraces[page + ".nft.json"];
-    };
+    const getBuildTraceFile = (page) => pageBuildTraces[page + ".nft.json"] || appBuildTraces[page + ".nft.json"];
     const pathsToTrace = mergedPageKeys.map((page) => {
-      if (!getBuildTraceFile(page)) {
+      const originalPagePath = getOriginalPagePath(page);
+      const pageBuildTrace = getBuildTraceFile(originalPagePath);
+      if (!pageBuildTrace) {
         return lambdaPages[page].fsPath;
       }
     }).filter(Boolean);
     let traceResult;
     let parentFilesMap;
     if (pathsToTrace.length > 0) {
+      console.warn(
+        `Warning: running tracing as trace files were not present for:
+`,
+        JSON.stringify(pathsToTrace, null, 2)
+      );
       traceResult = await (0, import_nft.nodeFileTrace)(pathsToTrace, {
         base: baseDir,
         cache: traceCache,
@@ -12264,28 +11923,37 @@ async function serverBuild({
         }
         reasons = traceResult?.reasons || /* @__PURE__ */ new Map();
       }
-      await Promise.all(
-        fileList.map(
-          collectTracedFiles(
+      await Promise.all([
+        createPseudoLayer({
+          files: {
+            [page]: lambdaPages[page]
+          },
+          lstatResults,
+          lstatSema
+        }).then((res) => {
+          compressedPages[page] = res.pseudoLayer[page];
+        }),
+        ...fileList.map(async (file) => {
+          await collectTracedFiles(
+            file,
             baseDir,
             lstatResults,
             lstatSema,
             reasons,
             tracedFiles
-          )
-        )
-      );
+          );
+        })
+      ]);
       pageTraces[page] = tracedFiles;
-      compressedPages[page] = (await createPseudoLayer({
-        [page]: lambdaPages[page]
-      })).pseudoLayer[page];
     }
-    const tracedPseudoLayer = await createPseudoLayer(
-      mergedPageKeys.reduce((prev, page) => {
+    const tracedPseudoLayer = await createPseudoLayer({
+      files: mergedPageKeys.reduce((prev, page) => {
         Object.assign(prev, pageTraces[page]);
         return prev;
-      }, {})
-    );
+      }, {}),
+      lstatResults,
+      lstatSema
+    });
     const pageExtensions = requiredServerFilesManifest.config?.pageExtensions;
     const pageLambdaGroups = await getPageLambdaGroups({
       entryPath: projectDir,
@@ -12297,8 +11965,6 @@ async function serverBuild({
       compressedPages,
       tracedPseudoLayer: tracedPseudoLayer.pseudoLayer,
       initialPseudoLayer,
-      lambdaCompressedByteLimit,
-      initialPseudoLayerUncompressed: uncompressedInitialSize,
       internalPages,
       pageExtensions
     });
@@ -12315,8 +11981,6 @@ async function serverBuild({
       compressedPages,
       tracedPseudoLayer: tracedPseudoLayer.pseudoLayer,
       initialPseudoLayer,
-      lambdaCompressedByteLimit,
-      initialPseudoLayerUncompressed: uncompressedInitialSize,
       internalPages,
       pageExtensions
     });
@@ -12330,8 +11994,6 @@ async function serverBuild({
       compressedPages,
       tracedPseudoLayer: tracedPseudoLayer.pseudoLayer,
       initialPseudoLayer,
-      lambdaCompressedByteLimit,
-      initialPseudoLayerUncompressed: uncompressedInitialSize,
       internalPages,
       pageExtensions
     });
@@ -12358,8 +12020,6 @@ async function serverBuild({
       compressedPages,
       tracedPseudoLayer: tracedPseudoLayer.pseudoLayer,
       initialPseudoLayer,
-      initialPseudoLayerUncompressed: uncompressedInitialSize,
-      lambdaCompressedByteLimit,
       internalPages,
       pageExtensions
     });
@@ -12372,27 +12032,23 @@ async function serverBuild({
           apiLambdaGroups: apiLambdaGroups.map((group) => ({
             pages: group.pages,
             isPrerender: group.isPrerenders,
-            pseudoLayerBytes: group.pseudoLayerBytes,
-            uncompressedLayerBytes: group.pseudoLayerUncompressedBytes
+            pseudoLayerBytes: group.pseudoLayerBytes
           })),
           pageLambdaGroups: pageLambdaGroups.map((group) => ({
             pages: group.pages,
             isPrerender: group.isPrerenders,
-            pseudoLayerBytes: group.pseudoLayerBytes,
-            uncompressedLayerBytes: group.pseudoLayerUncompressedBytes
+            pseudoLayerBytes: group.pseudoLayerBytes
           })),
           appRouterLambdaGroups: appRouterLambdaGroups.map((group) => ({
             pages: group.pages,
             isPrerender: group.isPrerenders,
-            pseudoLayerBytes: group.pseudoLayerBytes,
-            uncompressedLayerBytes: group.pseudoLayerUncompressedBytes
+            pseudoLayerBytes: group.pseudoLayerBytes
           })),
           appRouteHandlersLambdaGroups: appRouteHandlersLambdaGroups.map(
             (group) => ({
               pages: group.pages,
               isPrerender: group.isPrerenders,
-              pseudoLayerBytes: group.pseudoLayerBytes,
-              uncompressedLayerBytes: group.pseudoLayerUncompressedBytes
+              pseudoLayerBytes: group.pseudoLayerBytes
             })
           ),
           nextServerLayerSize: initialPseudoLayer.pseudoLayerBytes
@@ -12407,118 +12063,121 @@ async function serverBuild({
       ...apiLambdaGroups,
       ...appRouteHandlersLambdaGroups
     ];
-    await detectLambdaLimitExceeding(
-      combinedGroups,
-      lambdaCompressedByteLimit,
-      compressedPages
-    );
-    for (const group of combinedGroups) {
-      const groupPageFiles = {};
-      for (const page of [...group.pages, ...internalPages]) {
-        const pageFileName = import_path4.default.normalize(
-          import_path4.default.relative(baseDir, lambdaPages[page].fsPath)
-        );
-        groupPageFiles[pageFileName] = compressedPages[page];
-      }
-      const updatedManifestFiles = {};
-      if (isCorrectManifests) {
-        for (const manifest of [
-          "routes-manifest.json",
-          "server/pages-manifest.json"
-        ]) {
-          const fsPath = import_path4.default.join(entryPath, outputDirectory, manifest);
-          const relativePath = import_path4.default.relative(baseDir, fsPath);
-          delete group.pseudoLayer[relativePath];
-          const manifestData = await import_fs_extra5.default.readJSON(fsPath);
-          const normalizedPages = new Set(
-            group.pages.map((page) => {
-              page = `/${page.replace(/\.js$/, "")}`;
-              if (page === "/index")
-                page = "/";
-              return page;
-            })
+    await detectLambdaLimitExceeding(combinedGroups, compressedPages);
+    await Promise.all(
+      combinedGroups.map(async (group) => {
+        const groupPageFiles = {};
+        for (const page of [...group.pages, ...internalPages]) {
+          const pageFileName = import_path4.default.normalize(
+            import_path4.default.relative(baseDir, lambdaPages[page].fsPath)
           );
-          switch (manifest) {
-            case "routes-manifest.json": {
-              const filterItem = (item) => normalizedPages.has(item.page);
-              manifestData.dynamicRoutes = manifestData.dynamicRoutes?.filter(filterItem);
-              manifestData.staticRoutes = manifestData.staticRoutes?.filter(filterItem);
-              break;
-            }
-            case "server/pages-manifest.json": {
-              for (const key of Object.keys(manifestData)) {
-                if (isDynamicRoute(key) && !normalizedPages.has(key)) {
-                  delete manifestData[key];
+          groupPageFiles[pageFileName] = compressedPages[page];
+        }
+        const updatedManifestFiles = {};
+        if (isCorrectManifests) {
+          for (const manifest of [
+            "routes-manifest.json",
+            "server/pages-manifest.json"
+          ]) {
+            const fsPath = import_path4.default.join(entryPath, outputDirectory, manifest);
+            const relativePath = import_path4.default.relative(baseDir, fsPath);
+            delete group.pseudoLayer[relativePath];
+            const manifestData = await import_fs_extra5.default.readJSON(fsPath);
+            const normalizedPages = new Set(
+              group.pages.map((page) => {
+                page = `/${page.replace(/\.js$/, "")}`;
+                if (page === "/index")
+                  page = "/";
+                return page;
+              })
+            );
+            switch (manifest) {
+              case "routes-manifest.json": {
+                const filterItem = (item) => normalizedPages.has(item.page);
+                manifestData.dynamicRoutes = manifestData.dynamicRoutes?.filter(filterItem);
+                manifestData.staticRoutes = manifestData.staticRoutes?.filter(filterItem);
+                break;
+              }
+              case "server/pages-manifest.json": {
+                for (const key of Object.keys(manifestData)) {
+                  if (isDynamicRoute(key) && !normalizedPages.has(key)) {
+                    delete manifestData[key];
+                  }
                 }
+                break;
+              }
+              default: {
+                throw new import_build_utils2.NowBuildError({
+                  message: `Unexpected manifest value ${manifest}, please contact support if this continues`,
+                  code: "NEXT_MANIFEST_INVARIANT"
+                });
               }
-              break;
-            }
-            default: {
-              throw new import_build_utils2.NowBuildError({
-                message: `Unexpected manifest value ${manifest}, please contact support if this continues`,
-                code: "NEXT_MANIFEST_INVARIANT"
-              });
             }
+            updatedManifestFiles[relativePath] = new import_build_utils2.FileBlob({
+              contentType: "application/json",
+              data: JSON.stringify(manifestData)
+            });
           }
-          updatedManifestFiles[relativePath] = new import_build_utils2.FileBlob({
-            contentType: "application/json",
-            data: JSON.stringify(manifestData)
-          });
-        }
-      }
-      const launcherFiles = {
-        [import_path4.default.join(import_path4.default.relative(baseDir, projectDir), "___next_launcher.cjs")]: new import_build_utils2.FileBlob({ data: group.isAppRouter ? appLauncher : launcher })
-      };
-      const operationType = getOperationType({ group, prerenderManifest });
-      const lambda = await createLambdaFromPseudoLayers({
-        files: {
-          ...launcherFiles,
-          ...updatedManifestFiles
-        },
-        layers: [group.pseudoLayer, groupPageFiles],
-        handler: import_path4.default.join(
-          import_path4.default.relative(baseDir, projectDir),
-          "___next_launcher.cjs"
-        ),
-        operationType,
-        memory: group.memory,
-        runtime: nodeVersion.runtime,
-        maxDuration: group.maxDuration,
-        isStreaming: group.isStreaming,
-        nextVersion
-      });
-      for (const page of group.pages) {
-        const pageNoExt = page.replace(/\.js$/, "");
-        let isPrerender = prerenderRoutes.has(
-          import_path4.default.join("/", pageNoExt === "index" ? "" : pageNoExt)
-        );
-        if (!isPrerender && routesManifest?.i18n) {
-          isPrerender = routesManifest.i18n.locales.some((locale) => {
-            return prerenderRoutes.has(
-              import_path4.default.join("/", locale, pageNoExt === "index" ? "" : pageNoExt)
-            );
-          });
         }
-        const outputName = normalizeIndexOutput(
-          import_path4.default.posix.join(entryDirectory, pageNoExt),
-          true
-        );
-        if (i18n && !isPrerender && !group.isAppRouter && (!isCorrectLocaleAPIRoutes || !(pageNoExt === "api" || pageNoExt.startsWith("api/")))) {
-          for (const locale of i18n.locales) {
-            lambdas[normalizeIndexOutput(
-              import_path4.default.posix.join(
-                entryDirectory,
-                locale,
-                pageNoExt === "index" ? "" : pageNoExt
-              ),
-              true
-            )] = lambda;
+        const launcherFiles = {
+          [import_path4.default.join(
+            import_path4.default.relative(baseDir, projectDir),
+            "___next_launcher.cjs"
+          )]: new import_build_utils2.FileBlob({
+            data: group.isAppRouter ? appLauncher : launcher
+          })
+        };
+        const operationType = getOperationType({ group, prerenderManifest });
+        const lambda = await createLambdaFromPseudoLayers({
+          files: {
+            ...launcherFiles,
+            ...updatedManifestFiles
+          },
+          layers: [group.pseudoLayer, groupPageFiles],
+          handler: import_path4.default.join(
+            import_path4.default.relative(baseDir, projectDir),
+            "___next_launcher.cjs"
+          ),
+          operationType,
+          memory: group.memory,
+          runtime: nodeVersion.runtime,
+          maxDuration: group.maxDuration,
+          isStreaming: group.isStreaming,
+          nextVersion
+        });
+        for (const page of group.pages) {
+          const pageNoExt = page.replace(/\.js$/, "");
+          let isPrerender = prerenderRoutes.has(
+            import_path4.default.join("/", pageNoExt === "index" ? "" : pageNoExt)
+          );
+          if (!isPrerender && routesManifest?.i18n) {
+            isPrerender = routesManifest.i18n.locales.some((locale) => {
+              return prerenderRoutes.has(
+                import_path4.default.join("/", locale, pageNoExt === "index" ? "" : pageNoExt)
+              );
+            });
+          }
+          const outputName = normalizeIndexOutput(
+            import_path4.default.posix.join(entryDirectory, pageNoExt),
+            true
+          );
+          if (i18n && !isPrerender && !group.isAppRouter && (!isCorrectLocaleAPIRoutes || !(pageNoExt === "api" || pageNoExt.startsWith("api/")))) {
+            for (const locale of i18n.locales) {
+              lambdas[normalizeIndexOutput(
+                import_path4.default.posix.join(
+                  entryDirectory,
+                  locale,
+                  pageNoExt === "index" ? "" : pageNoExt
+                ),
+                true
+              )] = lambda;
+            }
+          } else {
+            lambdas[outputName] = lambda;
           }
-        } else {
-          lambdas[outputName] = lambda;
         }
-      }
-    }
+      })
+    );
     console.timeEnd(lambdaCreationLabel);
   }
   const prerenderRoute = onPrerenderRoute({
@@ -14296,6 +13955,8 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
     let tracedPseudoLayer;
     const apiPages = [];
     const nonApiPages = [];
+    const lstatSema = new import_async_sema2.Sema(25);
+    const lstatResults = {};
     for (const page of pageKeys) {
       const pagePath = pages[page].fsPath;
       const route = `/${page.replace(/\.js$/, "")}`;
@@ -14307,7 +13968,11 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         nonApiPages.push(page);
       }
       compressedPages[page] = (await createPseudoLayer({
-        [page]: pages[page]
+        files: {
+          [page]: pages[page]
+        },
+        lstatResults,
+        lstatSema
       })).pseudoLayer[page];
     }
     const mergedPageKeys = [...nonApiPages, ...apiPages];
@@ -14318,8 +13983,6 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         console.time(tracingLabel);
       }
       const nftCache = /* @__PURE__ */ Object.create(null);
-      const lstatSema = new import_async_sema3.Sema(25);
-      const lstatResults = {};
       const pathsToTrace = mergedPageKeys.map((page) => pages[page].fsPath);
       const result = await (0, import_nft2.nodeFileTrace)(pathsToTrace, {
         base: baseDir,
@@ -14343,15 +14006,16 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         }
         const reasons = result.reasons;
         await Promise.all(
-          Array.from(fileList).map(
-            collectTracedFiles(
+          Array.from(fileList).map(async (file) => {
+            await collectTracedFiles(
+              file,
               baseDir,
               lstatResults,
               lstatSema,
               reasons,
               tracedFiles
-            )
-          )
+            );
+          })
         );
         pageTraces[page] = tracedFiles;
       }
@@ -14362,12 +14026,14 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       if (hasLambdas) {
         console.time(zippingLabel);
       }
-      tracedPseudoLayer = await createPseudoLayer(
-        mergedPageKeys.reduce((prev, page) => {
+      tracedPseudoLayer = await createPseudoLayer({
+        files: mergedPageKeys.reduce((prev, page) => {
           Object.assign(prev, pageTraces[page]);
           return prev;
-        }, {})
-      );
+        }, {}),
+        lstatResults,
+        lstatSema
+      });
       if (hasLambdas) {
         console.timeEnd(zippingLabel);
       }

package/dist/server-launcher.js

@@ -10,6 +10,7 @@ if (process.env.NODE_ENV !== "production" && region !== "dev1") {
   );
   process.env.NODE_ENV = "production";
 }
+// @preserve pre-next-server-target
 const NextServer = require("__NEXT_SERVER_PATH__").default;
 const nextServer = new NextServer({
   // @ts-ignore __NEXT_CONFIG__ value is injected
@@ -21,6 +22,7 @@ const nextServer = new NextServer({
 const requestHandler = nextServer.getRequestHandler();
 module.exports = async (req, res) => {
   try {
+    // @preserve entryDirectory handler
     await requestHandler(req, res);
   } catch (err) {
     console.error(err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/next",
-  "version": "4.0.7",
+  "version": "4.0.9",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/next-js",
@@ -13,7 +13,7 @@
     "dist"
   ],
   "dependencies": {
-    "@vercel/nft": "0.24.1"
+    "@vercel/nft": "0.24.2"
   },
   "devDependencies": {
     "@types/aws-lambda": "8.10.19",
@@ -30,7 +30,7 @@
     "@types/semver": "6.0.0",
     "@types/text-table": "0.2.1",
     "@types/webpack-sources": "3.2.0",
-    "@vercel/build-utils": "7.2.1",
+    "@vercel/build-utils": "7.2.2",
     "@vercel/routing-utils": "3.0.0",
     "async-sema": "3.0.1",
     "buffer-crc32": "0.2.13",