@vercel/next 4.0.9 → 4.0.11

package/dist/index.js

@@ -514,6 +514,9 @@ var require_superstatic = __commonJS({
           if (r.missing) {
             route.missing = r.missing;
           }
+          if (r.statusCode) {
+            route.status = r.statusCode;
+          }
           return route;
         } catch (e) {
           throw new Error(`Failed to parse rewrite: ${JSON.stringify(r)}`);
@@ -837,7 +840,7 @@ var require_lib = __commonJS({
     function defaultInit() {
       return "1";
     }
-    var Sema3 = class {
+    var Sema4 = 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 +896,9 @@ var require_lib = __commonJS({
         return this.waiting.length;
       }
     };
-    exports.Sema = Sema3;
+    exports.Sema = Sema4;
     function RateLimit(rps, { timeUnit = 1e3, uniformDistribution = false } = {}) {
-      const sema = new Sema3(uniformDistribution ? 1 : rps);
+      const sema = new Sema4(uniformDistribution ? 1 : rps);
       const delay = uniformDistribution ? timeUnit / rps : timeUnit;
       return async function rl() {
         await sema.acquire();
@@ -5870,6 +5873,313 @@ 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) {
@@ -9078,7 +9388,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_sema2 = __toESM(require_lib());
+var import_async_sema3 = __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());
@@ -9093,9 +9403,12 @@ 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());
@@ -9174,6 +9487,7 @@ 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"));
@@ -9582,7 +9896,7 @@ function getFilesMapFromReasons(fileList, reasons, ignoreFn) {
   }
   return parentFilesMap;
 }
-var collectTracedFiles = async (file, baseDir, lstatResults, lstatSema, reasons, files) => {
+var collectTracedFiles = (baseDir, lstatResults, lstatSema, reasons, files) => async (file) => {
   const reason = reasons.get(file);
   if (reason && reason.type.includes("initial")) {
     return;
@@ -9598,42 +9912,47 @@ var collectTracedFiles = async (file, baseDir, lstatResults, lstatSema, reasons,
   });
 };
 var ExperimentalTraceVersion = `9.0.4-canary.1`;
-async function createPseudoLayer({
-  files,
-  lstatSema,
-  lstatResults
-}) {
-  let pseudoLayerBytes = 0;
-  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
-        };
+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);
       }
-      lstatSema.release();
-    })
-  );
+    );
+  });
+};
+async function createPseudoLayer(files) {
+  const pseudoLayer = {};
+  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
+      };
+    }
+  }
   return { pseudoLayer, pseudoLayerBytes };
 }
+var createLambdaSema = new import_async_sema.Sema(1);
 async function createLambdaFromPseudoLayers({
   files: baseFiles,
   layers,
@@ -9641,6 +9960,7 @@ async function createLambdaFromPseudoLayers({
   nextVersion,
   ...lambdaOptions
 }) {
+  await createLambdaSema.acquire();
   const files = {};
   const addedFiles = /* @__PURE__ */ new Set();
   for (const layer of layers) {
@@ -9661,6 +9981,7 @@ async function createLambdaFromPseudoLayers({
     files[fileName] = file;
     addedFiles.add(fileName);
   }
+  createLambdaSema.release();
   return new import_build_utils.NodejsLambda({
     ...lambdaOptions,
     ...isStreaming ? {
@@ -10005,6 +10326,8 @@ async function getPageLambdaGroups({
   compressedPages,
   tracedPseudoLayer,
   initialPseudoLayer,
+  initialPseudoLayerUncompressed,
+  lambdaCompressedByteLimit,
   internalPages,
   pageExtensions
 }) {
@@ -10032,18 +10355,22 @@ async function getPageLambdaGroups({
     let matchingGroup = groups.find((group) => {
       const matches = group.maxDuration === opts.maxDuration && group.memory === opts.memory && group.isPrerenders === isPrerenderRoute;
       if (matches) {
-        let newTracedFilesUncompressedSize = group.pseudoLayerBytes;
+        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;
-        return underUncompressedLimit;
+        const underCompressedLimit = newTracedFilesSize < lambdaCompressedByteLimit - LAMBDA_RESERVED_COMPRESSED_SIZE;
+        return underUncompressedLimit && underCompressedLimit;
       }
       return false;
     });
@@ -10056,6 +10383,7 @@ async function getPageLambdaGroups({
         isPrerenders: isPrerenderRoute,
         isApiLambda: !!isApiPage(page),
         pseudoLayerBytes: initialPseudoLayer.pseudoLayerBytes,
+        pseudoLayerUncompressedBytes: initialPseudoLayerUncompressed,
         pseudoLayer: Object.assign({}, initialPseudoLayer.pseudoLayer)
       };
       groups.push(newGroup);
@@ -10064,24 +10392,31 @@ 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 += pseudoItem.uncompressedSize || 0;
+          matchingGroup.pseudoLayerBytes += compressedSize;
+          matchingGroup.pseudoLayerUncompressedBytes += pseudoItem.uncompressedSize || 0;
         }
       });
-      matchingGroup.pseudoLayerBytes += compressedPages[newPage].uncompressedSize;
+      matchingGroup.pseudoLayerBytes += compressedPages[newPage].compBuffer.byteLength;
+      matchingGroup.pseudoLayerUncompressedBytes += compressedPages[newPage].uncompressedSize;
     }
   }
   return groups;
 }
-var outputFunctionFileSizeInfo = (pages, pseudoLayer, pseudoLayerBytes, compressedPages) => {
+var outputFunctionFileSizeInfo = (pages, pseudoLayer, pseudoLayerBytes, pseudoLayerUncompressedBytes, compressedPages) => {
   const exceededLimitOutput = [];
   console.log(
     `Serverless Function's page${pages.length === 1 ? "" : "s"}: ${pages.join(
       ", "
     )}`
   );
-  exceededLimitOutput.push(["Large Dependencies", "Uncompressed size"]);
+  exceededLimitOutput.push([
+    "Large Dependencies",
+    "Uncompressed size",
+    "Compressed size"
+  ]);
   const dependencies = {};
   for (const fileKey of Object.keys(pseudoLayer)) {
     if (!pseudoLayer[fileKey].isSymlink) {
@@ -10089,14 +10424,17 @@ var outputFunctionFileSizeInfo = (pages, pseudoLayer, pseudoLayerBytes, compress
       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
     };
   }
@@ -10104,19 +10442,23 @@ var outputFunctionFileSizeInfo = (pages, pseudoLayer, pseudoLayerBytes, compress
   Object.keys(dependencies).sort((a, b) => {
     const aDep = dependencies[a];
     const bDep = dependencies[b];
-    if (aDep.uncompressed > bDep.uncompressed) {
+    if (aDep.compressed > bDep.compressed) {
       return -1;
     }
-    if (aDep.uncompressed < bDep.uncompressed) {
+    if (aDep.compressed < bDep.compressed) {
       return 1;
     }
     return 0;
   }).forEach((depKey) => {
     const dep = dependencies[depKey];
-    if (dep.uncompressed < 500 * KIB) {
+    if (dep.compressed < 100 * KIB && dep.uncompressed < 500 * KIB) {
       return;
     }
-    exceededLimitOutput.push([depKey, prettyBytes(dep.uncompressed)]);
+    exceededLimitOutput.push([
+      depKey,
+      prettyBytes(dep.uncompressed),
+      prettyBytes(dep.compressed)
+    ]);
     numLargeDependencies += 1;
   });
   if (numLargeDependencies === 0) {
@@ -10125,21 +10467,26 @@ var outputFunctionFileSizeInfo = (pages, pseudoLayer, pseudoLayerBytes, compress
     ]);
   }
   exceededLimitOutput.push([]);
-  exceededLimitOutput.push(["All dependencies", prettyBytes(pseudoLayerBytes)]);
+  exceededLimitOutput.push([
+    "All dependencies",
+    prettyBytes(pseudoLayerUncompressedBytes),
+    prettyBytes(pseudoLayerBytes)
+  ]);
   console.log(
     (0, import_text_table.default)(exceededLimitOutput, {
       align: ["l", "r", "r"]
     })
   );
 };
-var detectLambdaLimitExceeding = async (lambdaGroups, compressedPages) => {
+var detectLambdaLimitExceeding = async (lambdaGroups, compressedSizeLimit, compressedPages) => {
+  const COMPRESSED_SIZE_LIMIT_CLOSE = compressedSizeLimit - 5 * MIB;
   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 > MAX_UNCOMPRESSED_LAMBDA_SIZE;
-    const closeToLimit = group.pseudoLayerBytes > UNCOMPRESSED_SIZE_LIMIT_CLOSE;
+    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;
     if (closeToLimit || exceededLimit || (0, import_build_utils.getPlatformEnv)("BUILDER_DEBUG") || process.env.NEXT_DEBUG_FUNCTION_SIZE) {
       if (exceededLimit) {
         numExceededLimit += 1;
@@ -10155,6 +10502,8 @@ var detectLambdaLimitExceeding = async (lambdaGroups, compressedPages) => {
       if (numExceededLimit || numCloseToLimit) {
         console.log(
           `Warning: Max serverless function size of ${prettyBytes(
+            compressedSizeLimit
+          )} compressed or ${prettyBytes(
             MAX_UNCOMPRESSED_LAMBDA_SIZE
           )} uncompressed${numExceededLimit ? "" : " almost"} reached`
         );
@@ -10167,6 +10516,7 @@ var detectLambdaLimitExceeding = async (lambdaGroups, compressedPages) => {
       group.pages,
       group.pseudoLayer,
       group.pseudoLayerBytes,
+      group.pseudoLayerUncompressedBytes,
       compressedPages
     );
   }
@@ -10654,13 +11004,13 @@ 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;
 }
 async function getMiddlewareBundle({
@@ -10985,6 +11335,46 @@ async function getVariantsManifest(entryPath, outputDirectory) {
   );
   return variantsManifest;
 }
+async function getServerlessPages(params) {
+  const appDir = import_path2.default.join(params.pagesDir, "../app");
+  const [pages, appPaths, middlewareManifest] = await Promise.all([
+    (0, import_build_utils.glob)("**/!(_middleware).js", params.pagesDir),
+    params.appPathRoutesManifest ? Promise.all([
+      (0, import_build_utils.glob)("**/page.js", appDir),
+      (0, import_build_utils.glob)("**/route.js", appDir),
+      (0, import_build_utils.glob)("**/_not-found.js", appDir)
+    ]).then((items) => Object.assign(...items)) : Promise.resolve({}),
+    getMiddlewareManifest(params.entryPath, params.outputDirectory)
+  ]);
+  const normalizedAppPaths = {};
+  if (params.appPathRoutesManifest) {
+    for (const [entry, normalizedEntry] of Object.entries(
+      params.appPathRoutesManifest
+    )) {
+      const normalizedPath = `${import_path2.default.join(
+        ".",
+        normalizedEntry === "/" ? "/index" : normalizedEntry
+      )}.js`;
+      const globPath = `${import_path2.default.posix.join(".", entry)}.js`;
+      if (appPaths[globPath]) {
+        normalizedAppPaths[normalizedPath] = appPaths[globPath];
+      }
+    }
+  }
+  for (const edgeFunctionFile of Object.keys(
+    middlewareManifest?.functions ?? {}
+  )) {
+    let edgePath = middlewareManifest?.functions?.[edgeFunctionFile].name || edgeFunctionFile;
+    edgePath = normalizeEdgeFunctionPath(
+      edgePath,
+      params.appPathRoutesManifest || {}
+    );
+    edgePath = (edgePath || "index") + ".js";
+    delete normalizedAppPaths[edgePath];
+    delete pages[edgePath];
+  }
+  return { pages, appPaths: normalizedAppPaths };
+}
 
 // src/create-serverless-config.ts
 function getCustomData(importName, target) {
@@ -11402,7 +11792,7 @@ var legacy_versions_default = [
 // src/server-build.ts
 var import_path4 = __toESM(require("path"));
 var import_semver3 = __toESM(require_semver());
-var import_async_sema = __toESM(require_lib());
+var import_async_sema2 = __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());
@@ -11414,7 +11804,7 @@ 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 CORRECTED_MANIFESTS_VERSION = "v12.2.0";
-var BUNDLED_SERVER_NEXT_VERSION = "13.4.20-canary.26";
+var BUNDLED_SERVER_NEXT_VERSION = "v13.5.4";
 var BUNDLED_SERVER_NEXT_PATH = "next/dist/compiled/next-server/server.runtime.prod.js";
 async function serverBuild({
   dynamicPages,
@@ -11454,6 +11844,7 @@ async function serverBuild({
   omittedPrerenderRoutes,
   trailingSlashRedirects,
   isCorrectLocaleAPIRoutes,
+  lambdaCompressedByteLimit,
   requiredServerFilesManifest,
   variantsManifest
 }) {
@@ -11482,6 +11873,10 @@ async function serverBuild({
     appBuildTraces = await (0, import_build_utils2.glob)("**/*.js.nft.json", appDir);
     appRscPrefetches = await (0, import_build_utils2.glob)(`**/*${RSC_PREFETCH_SUFFIX}`, appDir);
     const rscContentTypeHeader = routesManifest?.rsc?.contentTypeHeader || RSC_CONTENT_TYPE;
+    if (appRscPrefetches["index.prefetch.rsc"]) {
+      appRscPrefetches["__index.prefetch.rsc"] = appRscPrefetches["index.prefetch.rsc"];
+      delete appRscPrefetches["index.prefetch.rsc"];
+    }
     for (const value of Object.values(appRscPrefetches)) {
       if (!value.contentType) {
         value.contentType = rscContentTypeHeader;
@@ -11521,7 +11916,7 @@ async function serverBuild({
   if (!hasStatic500 && i18n) {
     hasStatic500 = !!staticPages[import_path4.default.posix.join(entryDirectory, i18n.defaultLocale, "500")];
   }
-  const lstatSema = new import_async_sema.Sema(25);
+  const lstatSema = new import_async_sema2.Sema(25);
   const lstatResults = {};
   const nonLambdaSsgPages = /* @__PURE__ */ new Set();
   Object.keys(prerenderManifest.staticRoutes).forEach((route) => {
@@ -11646,23 +12041,18 @@ async function serverBuild({
     }
     (0, import_build_utils2.debug)("collecting initial Next.js server files");
     await Promise.all(
-      initialFileList.map(async (file) => {
-        await collectTracedFiles(
-          file,
+      initialFileList.map(
+        collectTracedFiles(
           baseDir,
           lstatResults,
           lstatSema,
           initialFileReasons,
           initialTracedFiles
-        );
-      })
+        )
+      )
     );
     (0, import_build_utils2.debug)("creating initial pseudo layer");
-    const initialPseudoLayer = await createPseudoLayer({
-      files: initialTracedFiles,
-      lstatResults,
-      lstatSema
-    });
+    const initialPseudoLayer = await createPseudoLayer(initialTracedFiles);
     console.timeEnd(initialTracingLabel);
     const lambdaCreationLabel = "Created all serverless functions in";
     console.time(lambdaCreationLabel);
@@ -11670,13 +12060,13 @@ async function serverBuild({
     const nonApiPages = [];
     const appRouterPages = [];
     const appRouteHandlers = [];
-    for (const page of lambdaPageKeys) {
+    lambdaPageKeys.forEach((page) => {
       if (internalPages.includes(page) && page !== "404.js" && !(page === "_error.js" && !(static404Page || lambdaPages["404.js"]))) {
-        continue;
+        return;
       }
       const pathname = page.replace(/\.js$/, "");
       if (nonLambdaSsgPages.has(pathname)) {
-        continue;
+        return;
       }
       const normalizedPathname = normalizePage(pathname);
       if (isDynamicRoute(normalizedPathname)) {
@@ -11693,7 +12083,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,
@@ -11759,28 +12149,33 @@ async function serverBuild({
         });
       })
     );
-    const requiredFilesLayer = await createPseudoLayer({
-      files: requiredFiles,
-      lstatResults,
-      lstatSema
-    });
+    const requiredFilesLayer = await createPseudoLayer(requiredFiles);
     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(
         {
-          initializeSizeUncompressed: initialPseudoLayer.pseudoLayerBytes
+          uncompressedInitialSize,
+          compressedInitialSize: initialPseudoLayer.pseudoLayerBytes
         },
         null,
         2
       )
     );
-    if (initialPseudoLayer.pseudoLayerBytes > MAX_UNCOMPRESSED_LAMBDA_SIZE) {
+    if (initialPseudoLayer.pseudoLayerBytes > lambdaCompressedByteLimit || 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`
       );
@@ -11788,10 +12183,11 @@ 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 ${MAX_UNCOMPRESSED_LAMBDA_SIZE} bytes`,
+        message: `Required files read using Node.js fs library and node_modules exceed max lambda size of ${lambdaCompressedByteLimit} bytes`,
         code: "NEXT_REQUIRED_FILES_LIMIT",
         link: "https://vercel.com/docs/platform/limits#serverless-function-size"
       });
@@ -11842,22 +12238,17 @@ async function serverBuild({
       }
       return originalPagePath;
     };
-    const getBuildTraceFile = (page) => pageBuildTraces[page + ".nft.json"] || appBuildTraces[page + ".nft.json"];
+    const getBuildTraceFile = (page) => {
+      return pageBuildTraces[page + ".nft.json"] || appBuildTraces[page + ".nft.json"];
+    };
     const pathsToTrace = mergedPageKeys.map((page) => {
-      const originalPagePath = getOriginalPagePath(page);
-      const pageBuildTrace = getBuildTraceFile(originalPagePath);
-      if (!pageBuildTrace) {
+      if (!getBuildTraceFile(page)) {
         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,
@@ -11923,37 +12314,28 @@ async function serverBuild({
         }
         reasons = traceResult?.reasons || /* @__PURE__ */ new Map();
       }
-      await Promise.all([
-        createPseudoLayer({
-          files: {
-            [page]: lambdaPages[page]
-          },
-          lstatResults,
-          lstatSema
-        }).then((res) => {
-          compressedPages[page] = res.pseudoLayer[page];
-        }),
-        ...fileList.map(async (file) => {
-          await collectTracedFiles(
-            file,
+      await Promise.all(
+        fileList.map(
+          collectTracedFiles(
             baseDir,
             lstatResults,
             lstatSema,
             reasons,
             tracedFiles
-          );
-        })
-      ]);
+          )
+        )
+      );
       pageTraces[page] = tracedFiles;
+      compressedPages[page] = (await createPseudoLayer({
+        [page]: lambdaPages[page]
+      })).pseudoLayer[page];
     }
-    const tracedPseudoLayer = await createPseudoLayer({
-      files: mergedPageKeys.reduce((prev, page) => {
+    const tracedPseudoLayer = await createPseudoLayer(
+      mergedPageKeys.reduce((prev, page) => {
         Object.assign(prev, pageTraces[page]);
         return prev;
-      }, {}),
-      lstatResults,
-      lstatSema
-    });
+      }, {})
+    );
     const pageExtensions = requiredServerFilesManifest.config?.pageExtensions;
     const pageLambdaGroups = await getPageLambdaGroups({
       entryPath: projectDir,
@@ -11965,6 +12347,8 @@ async function serverBuild({
       compressedPages,
       tracedPseudoLayer: tracedPseudoLayer.pseudoLayer,
       initialPseudoLayer,
+      lambdaCompressedByteLimit,
+      initialPseudoLayerUncompressed: uncompressedInitialSize,
       internalPages,
       pageExtensions
     });
@@ -11981,6 +12365,8 @@ async function serverBuild({
       compressedPages,
       tracedPseudoLayer: tracedPseudoLayer.pseudoLayer,
       initialPseudoLayer,
+      lambdaCompressedByteLimit,
+      initialPseudoLayerUncompressed: uncompressedInitialSize,
       internalPages,
       pageExtensions
     });
@@ -11994,6 +12380,8 @@ async function serverBuild({
       compressedPages,
       tracedPseudoLayer: tracedPseudoLayer.pseudoLayer,
       initialPseudoLayer,
+      lambdaCompressedByteLimit,
+      initialPseudoLayerUncompressed: uncompressedInitialSize,
       internalPages,
       pageExtensions
     });
@@ -12020,6 +12408,8 @@ async function serverBuild({
       compressedPages,
       tracedPseudoLayer: tracedPseudoLayer.pseudoLayer,
       initialPseudoLayer,
+      initialPseudoLayerUncompressed: uncompressedInitialSize,
+      lambdaCompressedByteLimit,
       internalPages,
       pageExtensions
     });
@@ -12032,23 +12422,27 @@ async function serverBuild({
           apiLambdaGroups: apiLambdaGroups.map((group) => ({
             pages: group.pages,
             isPrerender: group.isPrerenders,
-            pseudoLayerBytes: group.pseudoLayerBytes
+            pseudoLayerBytes: group.pseudoLayerBytes,
+            uncompressedLayerBytes: group.pseudoLayerUncompressedBytes
           })),
           pageLambdaGroups: pageLambdaGroups.map((group) => ({
             pages: group.pages,
             isPrerender: group.isPrerenders,
-            pseudoLayerBytes: group.pseudoLayerBytes
+            pseudoLayerBytes: group.pseudoLayerBytes,
+            uncompressedLayerBytes: group.pseudoLayerUncompressedBytes
           })),
           appRouterLambdaGroups: appRouterLambdaGroups.map((group) => ({
             pages: group.pages,
             isPrerender: group.isPrerenders,
-            pseudoLayerBytes: group.pseudoLayerBytes
+            pseudoLayerBytes: group.pseudoLayerBytes,
+            uncompressedLayerBytes: group.pseudoLayerUncompressedBytes
           })),
           appRouteHandlersLambdaGroups: appRouteHandlersLambdaGroups.map(
             (group) => ({
               pages: group.pages,
               isPrerender: group.isPrerenders,
-              pseudoLayerBytes: group.pseudoLayerBytes
+              pseudoLayerBytes: group.pseudoLayerBytes,
+              uncompressedLayerBytes: group.pseudoLayerUncompressedBytes
             })
           ),
           nextServerLayerSize: initialPseudoLayer.pseudoLayerBytes
@@ -12063,121 +12457,118 @@ async function serverBuild({
       ...apiLambdaGroups,
       ...appRouteHandlersLambdaGroups
     ];
-    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)
+    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;
+            })
           );
-          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];
-                  }
+          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;
-            }
-          } else {
-            lambdas[outputName] = 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;
         }
-      })
-    );
+      }
+    }
     console.timeEnd(lambdaCreationLabel);
   }
   const prerenderRoute = onPrerenderRoute({
@@ -12606,7 +12997,7 @@ async function serverBuild({
             dest: import_path4.default.posix.join(
               "/",
               entryDirectory,
-              `/index${RSC_PREFETCH_SUFFIX}`
+              `/__index${RSC_PREFETCH_SUFFIX}`
             ),
             headers: { vary: rscVaryHeader },
             continue: true,
@@ -12693,7 +13084,7 @@ async function serverBuild({
           src: import_path4.default.posix.join(
             "/",
             entryDirectory,
-            `/index${RSC_PREFETCH_SUFFIX}`
+            `/__index${RSC_PREFETCH_SUFFIX}`
           ),
           dest: import_path4.default.posix.join("/", entryDirectory, "/index.rsc"),
           has: [
@@ -13955,8 +14346,6 @@ 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$/, "")}`;
@@ -13968,11 +14357,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         nonApiPages.push(page);
       }
       compressedPages[page] = (await createPseudoLayer({
-        files: {
-          [page]: pages[page]
-        },
-        lstatResults,
-        lstatSema
+        [page]: pages[page]
       })).pseudoLayer[page];
     }
     const mergedPageKeys = [...nonApiPages, ...apiPages];
@@ -13983,6 +14368,8 @@ 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,
@@ -14006,16 +14393,15 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         }
         const reasons = result.reasons;
         await Promise.all(
-          Array.from(fileList).map(async (file) => {
-            await collectTracedFiles(
-              file,
+          Array.from(fileList).map(
+            collectTracedFiles(
               baseDir,
               lstatResults,
               lstatSema,
               reasons,
               tracedFiles
-            );
-          })
+            )
+          )
         );
         pageTraces[page] = tracedFiles;
       }
@@ -14026,14 +14412,12 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       if (hasLambdas) {
         console.time(zippingLabel);
       }
-      tracedPseudoLayer = await createPseudoLayer({
-        files: mergedPageKeys.reduce((prev, page) => {
+      tracedPseudoLayer = await createPseudoLayer(
+        mergedPageKeys.reduce((prev, page) => {
           Object.assign(prev, pageTraces[page]);
           return prev;
-        }, {}),
-        lstatResults,
-        lstatSema
-      });
+        }, {})
+      );
       if (hasLambdas) {
         console.timeEnd(zippingLabel);
       }
@@ -14929,45 +15313,6 @@ var prepareCache = async ({
   (0, import_build_utils3.debug)("Cache file manifest produced");
   return cache;
 };
-async function getServerlessPages(params) {
-  const [pages, appPaths, middlewareManifest] = await Promise.all([
-    (0, import_build_utils3.glob)("**/!(_middleware).js", params.pagesDir),
-    params.appPathRoutesManifest ? Promise.all([
-      (0, import_build_utils3.glob)("**/page.js", import_path5.default.join(params.pagesDir, "../app")),
-      (0, import_build_utils3.glob)("**/route.js", import_path5.default.join(params.pagesDir, "../app")),
-      (0, import_build_utils3.glob)("**/_not-found.js", import_path5.default.join(params.pagesDir, "../app"))
-    ]).then((items) => Object.assign(...items)) : Promise.resolve({}),
-    getMiddlewareManifest(params.entryPath, params.outputDirectory)
-  ]);
-  const normalizedAppPaths = {};
-  if (params.appPathRoutesManifest) {
-    for (const [entry, normalizedEntry] of Object.entries(
-      params.appPathRoutesManifest
-    )) {
-      const normalizedPath = `${import_path5.default.join(
-        ".",
-        normalizedEntry === "/" ? "/index" : normalizedEntry
-      )}.js`;
-      const globPath = `${import_path5.default.join(".", entry)}.js`;
-      if (appPaths[globPath]) {
-        normalizedAppPaths[normalizedPath] = appPaths[globPath];
-      }
-    }
-  }
-  for (const edgeFunctionFile of Object.keys(
-    middlewareManifest?.functions ?? {}
-  )) {
-    let edgePath = middlewareManifest?.functions?.[edgeFunctionFile].name || edgeFunctionFile;
-    edgePath = normalizeEdgeFunctionPath(
-      edgePath,
-      params.appPathRoutesManifest || {}
-    );
-    edgePath = (edgePath || "index") + ".js";
-    delete normalizedAppPaths[edgePath];
-    delete pages[edgePath];
-  }
-  return { pages, appPaths: normalizedAppPaths };
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   MAX_AGE_ONE_YEAR,