@vercel/next 4.19.0 → 4.20.0

package/dist/adapter/index.js

@@ -9914,7 +9914,7 @@ async function handleNodeOutputs(nodeOutputs, {
       if (filesHashes) {
         filesHashes["___next_launcher.cjs"] = sha256(handlerSource);
       }
-      const operationType = output.type === import_constants.AdapterOutputType.APP_PAGE || import_constants.AdapterOutputType.PAGES ? "PAGE" : "API";
+      const operationType = output.type === import_constants.AdapterOutputType.APP_PAGE || output.type === import_constants.AdapterOutputType.PAGES ? "PAGE" : "API";
       const sourceFile = await getSourceFilePathFromPage({
         workPath: projectDir,
         page: output.sourcePage,
@@ -10231,7 +10231,7 @@ async function handleMiddleware(output, ctx) {
 }
 var _usesSrcCache;
 async function usesSrcDirectory(workPath) {
-  if (!_usesSrcCache) {
+  if (_usesSrcCache === void 0) {
     const sourcePages = import_node_path.default.join(workPath, "src", "pages");
     try {
       if ((await import_promises.default.stat(sourcePages)).isDirectory()) {
@@ -10241,7 +10241,7 @@ async function usesSrcDirectory(workPath) {
       _usesSrcCache = false;
     }
   }
-  if (!_usesSrcCache) {
+  if (_usesSrcCache === void 0) {
     const sourceAppdir = import_node_path.default.join(workPath, "src", "app");
     try {
       if ((await import_promises.default.stat(sourceAppdir)).isDirectory()) {
@@ -10251,7 +10251,10 @@ async function usesSrcDirectory(workPath) {
       _usesSrcCache = false;
     }
   }
-  return Boolean(_usesSrcCache);
+  if (_usesSrcCache === void 0) {
+    _usesSrcCache = false;
+  }
+  return _usesSrcCache;
 }
 function isDirectory(path3) {
   return import_fs_extra3.default.existsSync(path3) && import_fs_extra3.default.lstatSync(path3).isDirectory();
@@ -10624,8 +10627,10 @@ if(${cookieCheck}){
 var myAdapter = {
   name: "Vercel",
   async modifyConfig(config, ctx) {
-    if (ctx.phase === import_constants2.PHASE_PRODUCTION_BUILD && process.env.VERCEL_IMMUTABLE_STATIC_FILES_ENABLED === "1") {
-      config.experimental.supportsImmutableAssets = true;
+    if (ctx.phase === import_constants2.PHASE_PRODUCTION_BUILD) {
+      config.experimental.supportsImmutableAssets = // Default to true, allow users to opt-out
+      (config.experimental.supportsImmutableAssets ?? true) && // AND with infra support to allow disabling via feature flag if necessary.
+      process.env.VERCEL_IMMUTABLE_STATIC_FILES_ENABLED === "1";
     }
     if (process.env.VERCEL_HASH_SALT != null) {
       config.experimental.outputHashSalt = (config.experimental.outputHashSalt ?? "") + process.env.VERCEL_HASH_SALT;

package/dist/index.js

@@ -814,6 +814,7 @@ var require_superstatic = __commonJS({
     var superstatic_exports = {};
     __export2(superstatic_exports, {
       collectHasSegments: () => collectHasSegments,
+      compilePathToRegexpTemplate: () => compilePathToRegexpTemplate,
       convertCleanUrls: () => convertCleanUrls,
       convertHeaders: () => convertHeaders2,
       convertRedirects: () => convertRedirects2,
@@ -957,6 +958,22 @@ var require_superstatic = __commonJS({
             }
             route = { src, destination };
           }
+          if (r.transforms) {
+            route.transforms = r.transforms.map((transform) => {
+              if (transform.type !== "request.path") {
+                return { ...transform };
+              }
+              return {
+                ...transform,
+                args: compilePathToRegexpTemplateFromSegments(
+                  transform.args,
+                  segments,
+                  hasSegments,
+                  transform.env
+                )
+              };
+            });
+          }
           if (typeof r.env !== "undefined") {
             route.env = r.env;
           }
@@ -1097,6 +1114,81 @@ var require_superstatic = __commonJS({
     }
     var escapeSegment = (str, segmentName) => str.replace(new RegExp(`:${segmentName}`, "g"), `__ESC_COLON_${segmentName}`);
     var unescapeSegments = (str) => str.replace(/__ESC_COLON_/gi, ":");
+    var pathTemplateSegmentNameRegex = /^([a-zA-Z_][a-zA-Z0-9_]*)/;
+    function isEscaped(value, index) {
+      let backslashCount = 0;
+      for (let i = index - 1; i >= 0 && value[i] === "\\"; i--) {
+        backslashCount++;
+      }
+      return backslashCount % 2 === 1;
+    }
+    function collectPathTemplateSegments(template2) {
+      const segments = [];
+      for (let i = 0; i < template2.length; i++) {
+        if (template2[i] !== ":" || isEscaped(template2, i)) {
+          continue;
+        }
+        const match = template2.slice(i + 1).match(pathTemplateSegmentNameRegex);
+        if (match) {
+          segments.push(match[1]);
+          i += match[1].length;
+        }
+      }
+      return segments;
+    }
+    function collectNamedDollarReferences(template2) {
+      const references = [];
+      for (let i = 0; i < template2.length; i++) {
+        if (template2[i] !== "$" || isEscaped(template2, i)) {
+          continue;
+        }
+        const remainder = template2.slice(i + 1);
+        const bracedMatch = remainder.match(/^\{([a-zA-Z_][a-zA-Z0-9_]*)\}/);
+        const unbracedMatch = remainder.match(pathTemplateSegmentNameRegex);
+        const name = bracedMatch?.[1] || unbracedMatch?.[1];
+        if (name) {
+          references.push(name);
+        }
+      }
+      return references;
+    }
+    function compilePathToRegexpTemplateFromSegments(template2, segments, hasItemSegments, env = []) {
+      const indexes = {};
+      segments.forEach((name, index) => {
+        indexes[name] = toSegmentDest(index);
+      });
+      hasItemSegments.forEach((name) => {
+        indexes[name] = `$${name}`;
+      });
+      for (const name of collectPathTemplateSegments(template2)) {
+        if (!(name in indexes)) {
+          throw new Error(
+            `Path template references parameter ":${name}" that is not present in the source or has conditions.`
+          );
+        }
+      }
+      const routeParameters = /* @__PURE__ */ new Set([
+        ...segments.filter((name) => name !== UN_NAMED_SEGMENT),
+        ...hasItemSegments
+      ]);
+      for (const name of collectNamedDollarReferences(template2)) {
+        if (routeParameters.has(name) && !env.includes(name)) {
+          throw new Error(
+            `Path template references route parameter "${name}" as \`$${name}\`. Use \`:${name}\` path-to-regexp syntax in high-level rewrites, or list "${name}" in the transform env allowlist if it is an environment variable.`
+          );
+        }
+      }
+      return safelyCompile(template2, indexes, true);
+    }
+    function compilePathToRegexpTemplate(source, template2, has, env) {
+      const { segments } = sourceToRegex(source);
+      return compilePathToRegexpTemplateFromSegments(
+        template2,
+        segments,
+        collectHasSegments(has),
+        env
+      );
+    }
     function replaceSegments(segments, hasItemSegments, destination, isRedirect, internalParamNames) {
       const namedSegments = segments.filter((name) => name !== UN_NAMED_SEGMENT);
       const canNeedReplacing = destination.includes(":") && namedSegments.length > 0 || hasItemSegments.length > 0 || !isRedirect;
@@ -10942,6 +11034,7 @@ 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 DEFAULT_MAX_UNCOMPRESSED_LARGE_LAMBDA_SIZE = 5 * 1024 * MIB;
 var LAMBDA_RESERVED_UNCOMPRESSED_SIZE = 25 * MIB;
 var INTERNAL_PAGES = ["_app.js", "_error.js", "_document.js"];
 
@@ -11240,6 +11333,13 @@ function getMaxUncompressedLambdaSize(runtime) {
   }
   return runtime.startsWith("bun") ? DEFAULT_MAX_UNCOMPRESSED_LAMBDA_SIZE_BUN : DEFAULT_MAX_UNCOMPRESSED_LAMBDA_SIZE;
 }
+var LARGE_FUNCTIONS_ENV = "NEXT_EXPERIMENTAL_LARGE_FUNCTIONS";
+function isLargeFunctionsEnabled() {
+  return Boolean(process.env[LARGE_FUNCTIONS_ENV]);
+}
+function getGroupMaxUncompressedLambdaSize(runtime, isLargeFunctions) {
+  return isLargeFunctions ? DEFAULT_MAX_UNCOMPRESSED_LARGE_LAMBDA_SIZE : getMaxUncompressedLambdaSize(runtime);
+}
 var skipDefaultLocaleRewrite = Boolean(
   process.env.NEXT_EXPERIMENTAL_DEFER_DEFAULT_LOCALE_REWRITE
 );
@@ -12209,6 +12309,7 @@ async function getPageLambdaGroups({
   nodeVersion
 }) {
   const groups = [];
+  const largeFunctionsEnabled = isLargeFunctionsEnabled();
   for (const page of pages) {
     const newPages = [...internalPages, page];
     const routeName = normalizePage(page.replace(/\.js$/, ""));
@@ -12261,11 +12362,34 @@ async function getPageLambdaGroups({
         Object.assign(opts, config2.workflows);
       }
     }
-    let matchingGroup = experimentalAllowBundling ? void 0 : groups.find((group) => {
-      const matches = group.maxDuration === opts.maxDuration && 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;
+    let isLargeFunction = false;
+    if (largeFunctionsEnabled && !experimentalAllowBundling) {
+      let standaloneUncompressedSize = initialPseudoLayerUncompressed;
+      const countedFiles = new Set(
+        Object.keys(initialPseudoLayer.pseudoLayer)
+      );
+      for (const newPage of newPages) {
+        for (const file of Object.keys(pageTraces[newPage] || {})) {
+          if (!countedFiles.has(file)) {
+            countedFiles.add(file);
+            const item = tracedPseudoLayer[file];
+            standaloneUncompressedSize += item?.uncompressedSize || 0;
+          }
+        }
+        standaloneUncompressedSize += compressedPages[newPage].uncompressedSize;
+      }
+      const normalBudget = getMaxUncompressedLambdaSize(nodeVersion.runtime) - LAMBDA_RESERVED_UNCOMPRESSED_SIZE;
+      isLargeFunction = standaloneUncompressedSize >= normalBudget;
+    }
+    const skipGroupBundling = experimentalAllowBundling || isLargeFunction;
+    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.functionFailoverRegions,
+          opts.functionFailoverRegions
+        ) && group.isPrerenders === isPrerenderRoute && group.isExperimentalPPR === isExperimentalPPR && JSON.stringify(group.experimentalTriggers) === JSON.stringify(opts.experimentalTriggers) && group.supportsCancellation === opts.supportsCancellation
+      );
       if (matches) {
         let newTracedFilesUncompressedSize = group.pseudoLayerUncompressedBytes;
         for (const newPage of newPages) {
@@ -12277,8 +12401,9 @@ async function getPageLambdaGroups({
           });
           newTracedFilesUncompressedSize += compressedPages[newPage].uncompressedSize;
         }
-        const maxLambdaSize = getMaxUncompressedLambdaSize(
-          nodeVersion.runtime
+        const maxLambdaSize = getGroupMaxUncompressedLambdaSize(
+          nodeVersion.runtime,
+          isLargeFunction
         );
         const underUncompressedLimit = newTracedFilesUncompressedSize < maxLambdaSize - LAMBDA_RESERVED_UNCOMPRESSED_SIZE;
         return underUncompressedLimit;
@@ -12293,6 +12418,7 @@ async function getPageLambdaGroups({
         ...opts,
         isPrerenders: isPrerenderRoute,
         isExperimentalPPR,
+        isLargeFunctions: isLargeFunction,
         isApiLambda: !!isApiPage(page) || !!isRouteHandlers,
         pseudoLayerBytes: initialPseudoLayer.pseudoLayerBytes,
         pseudoLayerUncompressedBytes: initialPseudoLayerUncompressed,
@@ -12401,13 +12527,17 @@ var outputFunctionFileSizeInfo = (pages, pseudoLayer, pseudoLayerUncompressedByt
 };
 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 > maxLambdaSize;
-    const closeToLimit = group.pseudoLayerUncompressedBytes > UNCOMPRESSED_SIZE_LIMIT_CLOSE;
+    const groupMaxLambdaSize = getGroupMaxUncompressedLambdaSize(
+      runtime,
+      group.isLargeFunctions
+    );
+    const groupCloseLimit = groupMaxLambdaSize - 5 * MIB;
+    const exceededLimit = group.pseudoLayerUncompressedBytes > groupMaxLambdaSize;
+    const closeToLimit = group.pseudoLayerUncompressedBytes > groupCloseLimit;
     if (closeToLimit || exceededLimit || (0, import_build_utils.getPlatformEnv)("BUILDER_DEBUG") || process.env.NEXT_DEBUG_FUNCTION_SIZE) {
       if (exceededLimit) {
         numExceededLimit += 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/next",
-  "version": "4.19.0",
+  "version": "4.20.0",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/next-js",
@@ -16,7 +16,7 @@
     "@vercel/nft": "1.10.0"
   },
   "devDependencies": {
-    "@next-community/adapter-vercel": "0.0.1-beta.22",
+    "@next-community/adapter-vercel": "0.0.1-beta.23",
     "@types/aws-lambda": "8.10.19",
     "@types/buffer-crc32": "0.2.0",
     "@types/bytes": "3.1.1",
@@ -53,8 +53,8 @@
     "text-table": "0.2.0",
     "vitest": "2.0.3",
     "webpack-sources": "3.2.3",
-    "@vercel/build-utils": "13.30.0",
-    "@vercel/routing-utils": "6.3.0"
+    "@vercel/build-utils": "13.32.0",
+    "@vercel/routing-utils": "6.3.1"
   },
   "scripts": {
     "build": "node build.mjs",