@vercel/next 4.20.4 → 4.21.1

package/dist/index.js

@@ -11875,6 +11875,18 @@ async function createLambdaFromPseudoLayers({
     shouldDisableAutomaticFetchInstrumentation: process.env.VERCEL_TRACING_DISABLE_AUTOMATIC_FETCH_INSTRUMENTATION === "1"
   });
 }
+function toPrerenderClassification(entry) {
+  const { routeType, response, compute, htmlSize } = entry;
+  if (!routeType || !response || !compute) {
+    return void 0;
+  }
+  return {
+    routeType,
+    response,
+    compute,
+    ...htmlSize !== void 0 ? { htmlSize } : {}
+  };
+}
 async function getExportIntent(entryPath) {
   const pathExportMarker = import_path3.default.join(entryPath, ".next", "export-marker.json");
   const hasExportMarker = await import_fs_extra3.default.access(pathExportMarker, import_fs_extra3.default.constants.F_OK).then(() => true).catch(() => false);
@@ -12042,7 +12054,11 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
         let prefetchDataRoute;
         let allowHeader;
         let renderingMode;
+        let prerenderClassification;
         if (manifest.version === 4) {
+          prerenderClassification = toPrerenderClassification(
+            manifest.routes[route]
+          );
           initialExpireSeconds = manifest.routes[route].initialExpireSeconds;
           initialStatus = manifest.routes[route].initialStatus;
           initialHeaders = manifest.routes[route].initialHeaders;
@@ -12055,6 +12071,7 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
           allowHeader = void 0;
         }
         ret.staticRoutes[route] = {
+          prerenderClassification,
           initialRevalidate: initialRevalidateSeconds === false ? false : Math.max(1, initialRevalidateSeconds),
           initialExpire: initialExpireSeconds,
           dataRoute,
@@ -12080,7 +12097,11 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
         let fallbackRootParams;
         let allowHeader;
         let fallbackSourceRoute;
+        let prerenderClassification;
         if (manifest.version === 4) {
+          prerenderClassification = toPrerenderClassification(
+            manifest.dynamicRoutes[lazyRoute]
+          );
           experimentalBypassFor = manifest.dynamicRoutes[lazyRoute].experimentalBypassFor;
           prefetchDataRoute = manifest.dynamicRoutes[lazyRoute].prefetchDataRoute;
           prefetchDataRouteRegex = manifest.dynamicRoutes[lazyRoute].prefetchDataRouteRegex;
@@ -12097,6 +12118,7 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
         }
         if (typeof fallback === "string") {
           ret.fallbackRoutes[lazyRoute] = {
+            prerenderClassification,
             experimentalBypassFor,
             routeRegex,
             fallback,
@@ -12115,6 +12137,7 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
           };
         } else if (fallback === null) {
           ret.blockingFallbackRoutes[lazyRoute] = {
+            prerenderClassification,
             experimentalBypassFor,
             routeRegex,
             dataRoute,
@@ -12128,6 +12151,7 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
           };
         } else {
           ret.omittedRoutes[lazyRoute] = {
+            prerenderClassification,
             experimentalBypassFor,
             routeRegex,
             dataRoute,
@@ -12381,11 +12405,11 @@ async function getPageLambdaGroups({
       const normalBudget = getMaxUncompressedLambdaSize(nodeVersion.runtime) - LAMBDA_RESERVED_UNCOMPRESSED_SIZE;
       isLargeFunction = standaloneUncompressedSize >= normalBudget;
     }
-    const skipGroupBundling = experimentalAllowBundling || isLargeFunction;
+    const skipGroupBundling = experimentalAllowBundling || isLargeFunction || opts.maxConcurrency !== void 0;
     let matchingGroup = skipGroupBundling ? void 0 : groups.find((group) => {
       const matches = (
         // Never merge a normal route into a large (single-route) group.
-        (group.isLargeFunctions ?? false) === isLargeFunction && group.maxDuration === opts.maxDuration && group.memory === opts.memory && compareRegions(group.regions, opts.regions) && compareRegions(
+        (group.isLargeFunctions ?? false) === isLargeFunction && group.maxDuration === opts.maxDuration && group.maxConcurrency === opts.maxConcurrency && group.memory === opts.memory && compareRegions(group.regions, opts.regions) && compareRegions(
           group.functionFailoverRegions,
           opts.functionFailoverRegions
         ) && group.isPrerenders === isPrerenderRoute && group.isExperimentalPPR === isExperimentalPPR && JSON.stringify(group.experimentalTriggers) === JSON.stringify(opts.experimentalTriggers) && group.supportsCancellation === opts.supportsCancellation
@@ -12651,13 +12675,6 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
       message: "invariant: isOmitted and isFallback cannot both be true"
     });
   }
-  const routeIsDynamic = Boolean(isFallback || isBlocking || isOmitted);
-  let hasFallback;
-  if (isFallback) {
-    hasFallback = true;
-  } else if (isBlocking || isOmitted) {
-    hasFallback = false;
-  }
   let routeFileNoExt = routeKey === "/" ? "/index" : routeKey;
   let origRouteFileNoExt = routeFileNoExt;
   const { isLocalePrefixed } = prerenderManifest;
@@ -12689,8 +12706,10 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
   let experimentalBypassFor;
   let renderingMode;
   let allowHeader;
+  let prerenderClassification;
   if (isFallback || isBlocking) {
     const pr = isFallback ? prerenderManifest.fallbackRoutes[routeKey] : prerenderManifest.blockingFallbackRoutes[routeKey];
+    prerenderClassification = pr.prerenderClassification;
     initialRevalidate = 1;
     if (initialRevalidate === false) {
       throw new import_build_utils.NowBuildError({
@@ -12705,6 +12724,7 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
     renderingMode = pr.renderingMode;
     prefetchDataRoute = pr.prefetchDataRoute;
   } else if (isOmitted) {
+    prerenderClassification = prerenderManifest.omittedRoutes[routeKey].prerenderClassification;
     initialRevalidate = false;
     srcRoute = routeKey;
     dataRoute = prerenderManifest.omittedRoutes[routeKey].dataRoute;
@@ -12714,6 +12734,7 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
     prefetchDataRoute = prerenderManifest.omittedRoutes[routeKey].prefetchDataRoute;
   } else {
     const pr = prerenderManifest.staticRoutes[routeKey];
+    prerenderClassification = pr.prerenderClassification;
     ({
       initialRevalidate,
       initialExpire,
@@ -12758,23 +12779,12 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
   }
   const isOmittedOrNotFound = isOmitted || isNotFound;
   let htmlFallbackFsRef = null;
-  let htmlSize;
-  if (appDir) {
-    try {
-      htmlSize = import_fs_extra3.default.statSync(
-        import_path3.default.join(appDir, `${routeFileNoExt}.html`)
-      ).size;
-    } catch {
-    }
-  }
   let postponedPrerender;
   let postponedState = null;
   let didPostpone = false;
-  let hasPostponed;
   if (renderingMode === "PARTIALLY_STATIC" /* PARTIALLY_STATIC */ && appDir && // TODO(NAR-402): Investigate omitted routes
   !isBlocking) {
     postponedState = getHTMLPostponedState({ appDir, routeFileNoExt });
-    hasPostponed = Boolean(postponedState);
     const htmlPath = import_path3.default.join(appDir, `${routeFileNoExt}.html`);
     if (import_fs_extra3.default.existsSync(htmlPath)) {
       const html = import_fs_extra3.default.readFileSync(htmlPath, "utf8");
@@ -13043,10 +13053,11 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
         chain,
         allowHeader,
         partialFallback: partialFallback || void 0,
-        hasPostponed,
-        hasFallback,
-        htmlSize,
-        isDynamicRoute: routeIsDynamic,
+        // The classification goes on the primary output only, so each route
+        // group has exactly one classified entry; the sibling data and
+        // segment prerenders below are grouped back to it by `sourcePath`
+        // downstream.
+        prerenderClassification,
         ...isNotFound ? {
           initialStatus: 404
         } : {},
@@ -13080,9 +13091,6 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
         experimentalBypassFor,
         allowHeader,
         partialFallback: void 0,
-        hasPostponed,
-        hasFallback,
-        isDynamicRoute: routeIsDynamic,
         ...isNotFound ? {
           initialStatus: 404
         } : {},
@@ -13137,9 +13145,6 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
             experimentalBypassFor,
             allowHeader,
             partialFallback: void 0,
-            hasPostponed,
-            hasFallback,
-            isDynamicRoute: routeIsDynamic,
             chain: {
               outputPath: normalizePathData(outputPathData),
               headers: routesManifest.ppr.chain.headers
@@ -13206,9 +13211,6 @@ var onPrerenderRoute = (prerenderRouteArgs) => async (routeKey, {
               group: prerenderGroup,
               allowHeader,
               partialFallback: void 0,
-              hasPostponed,
-              hasFallback,
-              isDynamicRoute: routeIsDynamic,
               // These routes are always only static, so they should not
               // permit any bypass unless it's for preview
               bypassToken: prerenderManifest.bypassToken,
@@ -15438,6 +15440,7 @@ ${JSON.stringify(
         functionFailoverRegions: group.functionFailoverRegions,
         runtime: nodeVersion.runtime,
         maxDuration: group.maxDuration,
+        maxConcurrency: group.maxConcurrency,
         supportsCancellation: group.supportsCancellation,
         isStreaming: group.isStreaming,
         nextVersion,
@@ -18035,6 +18038,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
               isApiLambda: !!routeIsApi,
               pseudoLayer: group.pseudoLayer,
               lambdaCombinedBytes: group.pseudoLayerBytes,
+              maxConcurrency: group.maxConcurrency,
               lambdaIdentifier: import_path6.default.join(
                 entryDirectory,
                 `__NEXT_${routeIsApi ? "API" : "PAGE"}_LAMBDA_${lambdaGroupIndex}`
@@ -18369,6 +18373,7 @@ More info: http://err.sh/vercel/vercel/next-functions-config-optimized-lambdas`
               ),
               operationType,
               runtime: nodeVersion.runtime,
+              maxConcurrency: group.maxConcurrency,
               nextVersion
             });
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/next",
-  "version": "4.20.4",
+  "version": "4.21.1",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/next-js",
@@ -53,8 +53,8 @@
     "text-table": "0.2.0",
     "vitest": "2.0.3",
     "webpack-sources": "3.2.3",
-    "@vercel/routing-utils": "6.4.0",
-    "@vercel/build-utils": "13.32.3"
+    "@vercel/build-utils": "14.0.1",
+    "@vercel/routing-utils": "6.4.1"
   },
   "scripts": {
     "build": "node build.mjs",