@vercel/next 4.14.0 → 4.15.0

package/dist/index.js

@@ -10924,6 +10924,7 @@ var KIB = 1024;
 var MIB = 1024 * KIB;
 var EDGE_FUNCTION_SIZE_LIMIT = 4 * MIB;
 var DEFAULT_MAX_UNCOMPRESSED_LAMBDA_SIZE = 250 * MIB;
+var DEFAULT_MAX_UNCOMPRESSED_LAMBDA_SIZE_BUN = 150 * MIB;
 var LAMBDA_RESERVED_UNCOMPRESSED_SIZE = 25 * MIB;
 var INTERNAL_PAGES = ["_app.js", "_error.js", "_document.js"];
 
@@ -11115,9 +11116,12 @@ function getAppRouterPathnameFilesMap(files) {
 var require_ = (0, import_module.createRequire)(__filename);
 var RSC_CONTENT_TYPE = "x-component";
 var RSC_PREFETCH_SUFFIX = ".prefetch.rsc";
-var MAX_UNCOMPRESSED_LAMBDA_SIZE = !isNaN(
-  Number(process.env.MAX_UNCOMPRESSED_LAMBDA_SIZE)
-) ? Number(process.env.MAX_UNCOMPRESSED_LAMBDA_SIZE) : DEFAULT_MAX_UNCOMPRESSED_LAMBDA_SIZE;
+function getMaxUncompressedLambdaSize(runtime) {
+  if (!isNaN(Number(process.env.MAX_UNCOMPRESSED_LAMBDA_SIZE))) {
+    return Number(process.env.MAX_UNCOMPRESSED_LAMBDA_SIZE);
+  }
+  return runtime.startsWith("bun") ? DEFAULT_MAX_UNCOMPRESSED_LAMBDA_SIZE_BUN : DEFAULT_MAX_UNCOMPRESSED_LAMBDA_SIZE;
+}
 var skipDefaultLocaleRewrite = Boolean(
   process.env.NEXT_EXPERIMENTAL_DEFER_DEFAULT_LOCALE_REWRITE
 );
@@ -11962,48 +11966,53 @@ async function usesSrcDirectory(workPath) {
 async function getSourceFilePathFromPage({
   workPath,
   page,
-  pageExtensions
+  pageExtensions,
+  nextVersion
 }) {
   const usesSrcDir = await usesSrcDirectory(workPath);
   const extensionsToTry = pageExtensions || ["js", "jsx", "ts", "tsx"];
-  for (const pageType of [
-    // middleware is not nested in pages/app
-    ...page === "middleware" ? [""] : ["pages", "app"]
-  ]) {
-    let fsPath = import_path3.default.join(workPath, pageType, page);
-    if (usesSrcDir) {
-      fsPath = import_path3.default.join(workPath, "src", pageType, page);
-    }
-    if (import_fs_extra3.default.existsSync(fsPath)) {
-      return import_path3.default.relative(workPath, fsPath);
-    }
-    const extensionless = fsPath.replace(import_path3.default.extname(fsPath), "");
-    for (const ext of extensionsToTry) {
-      fsPath = `${extensionless}.${ext}`;
-      if (pageType === "app" && extensionless === import_path3.default.join(workPath, `${usesSrcDir ? "src/" : ""}app/index`)) {
-        fsPath = `${extensionless.replace(/index$/, "page")}.${ext}`;
+  const isNextJs16Plus = nextVersion && import_semver.default.gte(nextVersion, "16.0.0");
+  const pagesToCheck = page === "middleware" && isNextJs16Plus ? ["proxy", "middleware"] : [page];
+  for (const pageToCheck of pagesToCheck) {
+    for (const pageType of [
+      // middleware/proxy is not nested in pages/app
+      ...pageToCheck === "middleware" || pageToCheck === "proxy" ? [""] : ["pages", "app"]
+    ]) {
+      let fsPath = import_path3.default.join(workPath, pageType, pageToCheck);
+      if (usesSrcDir) {
+        fsPath = import_path3.default.join(workPath, "src", pageType, pageToCheck);
       }
       if (import_fs_extra3.default.existsSync(fsPath)) {
         return import_path3.default.relative(workPath, fsPath);
       }
-    }
-    if (isDirectory(extensionless)) {
-      if (pageType === "pages") {
-        for (const ext of extensionsToTry) {
-          fsPath = import_path3.default.join(extensionless, `index.${ext}`);
-          if (import_fs_extra3.default.existsSync(fsPath)) {
-            return import_path3.default.relative(workPath, fsPath);
-          }
+      const extensionless = fsPath.replace(import_path3.default.extname(fsPath), "");
+      for (const ext of extensionsToTry) {
+        fsPath = `${extensionless}.${ext}`;
+        if (pageType === "app" && extensionless === import_path3.default.join(workPath, `${usesSrcDir ? "src/" : ""}app/index`)) {
+          fsPath = `${extensionless.replace(/index$/, "page")}.${ext}`;
         }
-      } else {
-        for (const ext of extensionsToTry) {
-          fsPath = import_path3.default.join(extensionless, `page.${ext}`);
-          if (import_fs_extra3.default.existsSync(fsPath)) {
-            return import_path3.default.relative(workPath, fsPath);
+        if (import_fs_extra3.default.existsSync(fsPath)) {
+          return import_path3.default.relative(workPath, fsPath);
+        }
+      }
+      if (isDirectory(extensionless)) {
+        if (pageType === "pages") {
+          for (const ext of extensionsToTry) {
+            fsPath = import_path3.default.join(extensionless, `index.${ext}`);
+            if (import_fs_extra3.default.existsSync(fsPath)) {
+              return import_path3.default.relative(workPath, fsPath);
+            }
           }
-          fsPath = import_path3.default.join(extensionless, `route.${ext}`);
-          if (import_fs_extra3.default.existsSync(fsPath)) {
-            return import_path3.default.relative(workPath, fsPath);
+        } else {
+          for (const ext of extensionsToTry) {
+            fsPath = import_path3.default.join(extensionless, `page.${ext}`);
+            if (import_fs_extra3.default.existsSync(fsPath)) {
+              return import_path3.default.relative(workPath, fsPath);
+            }
+            fsPath = import_path3.default.join(extensionless, `route.${ext}`);
+            if (import_fs_extra3.default.existsSync(fsPath)) {
+              return import_path3.default.relative(workPath, fsPath);
+            }
           }
         }
       }
@@ -12015,6 +12024,9 @@ async function getSourceFilePathFromPage({
   if (page === "/_global-error/page") {
     return "";
   }
+  if (page === "middleware" && isNextJs16Plus) {
+    return "";
+  }
   if (!INTERNAL_PAGES.includes(page)) {
     console.log(
       `WARNING: Unable to find source file for page ${page} with extensions: ${extensionsToTry.join(
@@ -12067,7 +12079,8 @@ async function getPageLambdaGroups({
   pageExtensions,
   inversedAppPathManifest,
   experimentalAllowBundling,
-  isRouteHandlers
+  isRouteHandlers,
+  nodeVersion
 }) {
   const groups = [];
   for (const page of pages) {
@@ -12132,7 +12145,10 @@ async function getPageLambdaGroups({
           });
           newTracedFilesUncompressedSize += compressedPages[newPage].uncompressedSize;
         }
-        const underUncompressedLimit = newTracedFilesUncompressedSize < MAX_UNCOMPRESSED_LAMBDA_SIZE - LAMBDA_RESERVED_UNCOMPRESSED_SIZE;
+        const maxLambdaSize = getMaxUncompressedLambdaSize(
+          nodeVersion.runtime
+        );
+        const underUncompressedLimit = newTracedFilesUncompressedSize < maxLambdaSize - LAMBDA_RESERVED_UNCOMPRESSED_SIZE;
         return underUncompressedLimit;
       }
       return false;
@@ -12251,13 +12267,14 @@ var outputFunctionFileSizeInfo = (pages, pseudoLayer, pseudoLayerUncompressedByt
     })
   );
 };
-var detectLambdaLimitExceeding = async (lambdaGroups, compressedPages) => {
-  const UNCOMPRESSED_SIZE_LIMIT_CLOSE = MAX_UNCOMPRESSED_LAMBDA_SIZE - 5 * MIB;
+var detectLambdaLimitExceeding = async (lambdaGroups, compressedPages, runtime) => {
+  const maxLambdaSize = getMaxUncompressedLambdaSize(runtime);
+  const UNCOMPRESSED_SIZE_LIMIT_CLOSE = maxLambdaSize - 5 * MIB;
   let numExceededLimit = 0;
   let numCloseToLimit = 0;
   let loggedHeadInfo = false;
   const filteredGroups = lambdaGroups.filter((group) => {
-    const exceededLimit = group.pseudoLayerUncompressedBytes > MAX_UNCOMPRESSED_LAMBDA_SIZE;
+    const exceededLimit = group.pseudoLayerUncompressedBytes > maxLambdaSize;
     const closeToLimit = group.pseudoLayerUncompressedBytes > UNCOMPRESSED_SIZE_LIMIT_CLOSE;
     if (closeToLimit || exceededLimit || (0, import_build_utils.getPlatformEnv)("BUILDER_DEBUG") || process.env.NEXT_DEBUG_FUNCTION_SIZE) {
       if (exceededLimit) {
@@ -12274,7 +12291,7 @@ var detectLambdaLimitExceeding = async (lambdaGroups, compressedPages) => {
       if (numExceededLimit || numCloseToLimit) {
         console.log(
           `Warning: Max serverless function size of ${prettyBytes(
-            MAX_UNCOMPRESSED_LAMBDA_SIZE
+            maxLambdaSize
           )} uncompressed${numExceededLimit ? "" : " almost"} reached`
         );
       } else {
@@ -13143,7 +13160,8 @@ async function getNodeMiddleware({
   const sourceFile = await getSourceFilePathFromPage({
     workPath: entryPath,
     page: normalizeSourceFilePageFromManifest("/middleware", "middleware", {}),
-    pageExtensions
+    pageExtensions,
+    nextVersion
   });
   const vercelConfigOpts = await (0, import_build_utils.getLambdaOptionsFromFunction)({
     sourceFile,
@@ -14613,10 +14631,11 @@ async function serverBuild({
         2
       )
     );
-    if (uncompressedInitialSize > MAX_UNCOMPRESSED_LAMBDA_SIZE) {
+    const maxLambdaSize = getMaxUncompressedLambdaSize(nodeVersion.runtime);
+    if (uncompressedInitialSize > maxLambdaSize) {
       console.log(
         `Warning: Max serverless function size of ${(0, import_pretty_bytes3.default)(
-          MAX_UNCOMPRESSED_LAMBDA_SIZE
+          maxLambdaSize
         )} uncompressed reached`
       );
       outputFunctionFileSizeInfo(
@@ -14626,7 +14645,7 @@ async function serverBuild({
         {}
       );
       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 ${maxLambdaSize} bytes`,
         code: "NEXT_REQUIRED_FILES_LIMIT",
         link: "https://vercel.com/docs/platform/limits#serverless-function-size"
       });
@@ -14788,7 +14807,8 @@ ${JSON.stringify(
       initialPseudoLayer,
       initialPseudoLayerUncompressed: uncompressedInitialSize,
       internalPages,
-      pageExtensions
+      pageExtensions,
+      nodeVersion
     });
     for (const group of pageLambdaGroups) {
       group.isPages = true;
@@ -14808,7 +14828,8 @@ ${JSON.stringify(
       initialPseudoLayerUncompressed: uncompressedInitialSize,
       internalPages,
       pageExtensions,
-      inversedAppPathManifest
+      inversedAppPathManifest,
+      nodeVersion
     });
     const appRouteHandlersLambdaGroups = await getPageLambdaGroups({
       experimentalAllowBundling,
@@ -14826,7 +14847,8 @@ ${JSON.stringify(
       internalPages,
       pageExtensions,
       inversedAppPathManifest,
-      isRouteHandlers: true
+      isRouteHandlers: true,
+      nodeVersion
     });
     const appRouterStreamingActionLambdaGroups = [];
     for (const group of appRouterLambdaGroups) {
@@ -14853,7 +14875,8 @@ ${JSON.stringify(
       initialPseudoLayer,
       initialPseudoLayerUncompressed: uncompressedInitialSize,
       internalPages,
-      pageExtensions
+      pageExtensions,
+      nodeVersion
     });
     for (const group of apiLambdaGroups) {
       group.isApiLambda = true;
@@ -14916,7 +14939,11 @@ ${JSON.stringify(
       ...apiLambdaGroups,
       ...appRouteHandlersLambdaGroups
     ];
-    await detectLambdaLimitExceeding(combinedGroups, compressedPages);
+    await detectLambdaLimitExceeding(
+      combinedGroups,
+      compressedPages,
+      nodeVersion.runtime
+    );
     const appNotFoundTraces = pageTraces["_not-found.js"];
     const appNotFoundPsuedoLayer = appNotFoundTraces && await createPseudoLayer(appNotFoundTraces);
     for (const group of combinedGroups) {
@@ -17419,7 +17446,8 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         // internal pages are already referenced in traces for serverless
         // like builds
         internalPages: [],
-        experimentalPPRRoutes: void 0
+        experimentalPPRRoutes: void 0,
+        nodeVersion
       });
       const initialApiLambdaGroups = await getPageLambdaGroups({
         entryPath,
@@ -17433,7 +17461,8 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
         initialPseudoLayer: { pseudoLayer: {}, pseudoLayerBytes: 0 },
         initialPseudoLayerUncompressed: 0,
         internalPages: [],
-        experimentalPPRRoutes: void 0
+        experimentalPPRRoutes: void 0,
+        nodeVersion
       });
       for (const group of initialApiLambdaGroups) {
         group.isApiLambda = true;
@@ -17462,7 +17491,8 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
       ];
       await detectLambdaLimitExceeding(
         combinedInitialLambdaGroups,
-        compressedPages
+        compressedPages,
+        nodeVersion.runtime
       );
       let apiLambdaGroupIndex = 0;
       let nonApiLambdaGroupIndex = 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/next",
-  "version": "4.14.0",
+  "version": "4.15.0",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/next-js",
@@ -30,8 +30,8 @@
     "@types/semver": "6.0.0",
     "@types/text-table": "0.2.1",
     "@types/webpack-sources": "3.2.0",
-    "@vercel/build-utils": "12.2.0",
-    "@vercel/routing-utils": "5.2.0",
+    "@vercel/build-utils": "12.2.3",
+    "@vercel/routing-utils": "5.2.1",
     "async-sema": "3.0.1",
     "buffer-crc32": "0.2.13",
     "bytes": "3.1.2",