@vercel/next 2.7.9 → 2.8.66-canary.0

package/dist/utils.js

@@ -1,19 +1,43 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSourceFilePathFromPage = exports.isDynamicRoute = exports.normalizePage = exports.syncEnvVars = exports.getRoutes = exports.getPathsInside = exports.getNextConfig = exports.normalizePackageJson = exports.excludeLockFiles = exports.validateEntrypoint = exports.excludeFiles = exports.addLocaleOrDefault = exports.normalizeLocalePath = exports.getPrerenderManifest = exports.getExportStatus = exports.getExportIntent = exports.createLambdaFromPseudoLayers = exports.createPseudoLayer = exports.ExperimentalTraceVersion = exports.getImagesManifest = exports.getDynamicRoutes = exports.getRoutesManifest = void 0;
+exports.getMiddlewareBundle = exports.getSourceFilePathFromPage = exports.isDynamicRoute = exports.normalizePage = exports.getNextConfig = exports.normalizePackageJson = exports.validateEntrypoint = exports.excludeFiles = exports.getPrivateOutputs = exports.updateRouteSrc = exports.getNextServerPath = exports.normalizeIndexOutput = exports.getStaticFiles = exports.onPrerenderRoute = exports.onPrerenderRouteInitial = exports.detectLambdaLimitExceeding = exports.outputFunctionFileSizeInfo = exports.getPageLambdaGroups = exports.MAX_UNCOMPRESSED_LAMBDA_SIZE = exports.addLocaleOrDefault = exports.normalizeLocalePath = exports.getPrerenderManifest = exports.getRequiredServerFilesManifest = exports.getExportStatus = exports.getExportIntent = exports.createLambdaFromPseudoLayers = exports.createPseudoLayer = exports.ExperimentalTraceVersion = exports.collectTracedFiles = exports.getFilesMapFromReasons = exports.filterStaticPages = exports.getImagesManifest = exports.localizeDynamicRoutes = exports.getDynamicRoutes = exports.getRoutesManifest = void 0;
+const build_utils_1 = require("@vercel/build-utils");
 const async_sema_1 = require("async-sema");
 const buffer_crc32_1 = __importDefault(require("buffer-crc32"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
+const fs_extra_1 = __importStar(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const resolve_from_1 = __importDefault(require("resolve-from"));
 const semver_1 = __importDefault(require("semver"));
-const yazl_1 = require("yazl");
 const zlib_1 = __importDefault(require("zlib"));
-const build_utils_1 = __importDefault(require("./build-utils"));
-const { streamToBuffer, Lambda, NowBuildError, isSymbolicLink } = build_utils_1.default;
+const url_1 = __importDefault(require("url"));
+const escape_string_regexp_1 = __importDefault(require("escape-string-regexp"));
+const _1 = require(".");
+const text_table_1 = __importDefault(require("text-table"));
+const pretty_bytes_1 = __importDefault(require("pretty-bytes"));
+const get_edge_function_source_1 = require("./edge-function-source/get-edge-function-source");
+const sourcemapped_1 = require("./sourcemapped");
 // Identify /[param]/ in route string
 // eslint-disable-next-line no-useless-escape
 const TEST_DYNAMIC_ROUTE = /\/\[[^\/]+?\](?=\/|$)/;
@@ -28,7 +52,7 @@ exports.isDynamicRoute = isDynamicRoute;
 function validateEntrypoint(entrypoint) {
     if (!/package\.json$/.exec(entrypoint) &&
         !/next\.config\.js$/.exec(entrypoint)) {
-        throw new NowBuildError({
+        throw new build_utils_1.NowBuildError({
             message: 'Specified "src" for "@vercel/next" has to be "package.json" or "next.config.js"',
             code: 'NEXT_INCORRECT_SRC',
         });
@@ -50,20 +74,6 @@ function excludeFiles(files, matcher) {
     }, {});
 }
 exports.excludeFiles = excludeFiles;
-/**
- * Exclude package manager lockfiles from files
- */
-function excludeLockFiles(files) {
-    const newFiles = files;
-    if (newFiles['package-lock.json']) {
-        delete newFiles['package-lock.json'];
-    }
-    if (newFiles['yarn.lock']) {
-        delete newFiles['yarn.lock'];
-    }
-    return files;
-}
-exports.excludeLockFiles = excludeLockFiles;
 /**
  * Enforce specific package.json configuration for smallest possible lambda
  */
@@ -116,22 +126,6 @@ async function getNextConfig(workPath, entryPath) {
     return null;
 }
 exports.getNextConfig = getNextConfig;
-function pathIsInside(firstPath, secondPath) {
-    return !path_1.default.relative(firstPath, secondPath).startsWith('..');
-}
-function getPathsInside(entryDirectory, files) {
-    const watch = [];
-    for (const file of Object.keys(files)) {
-        // If the file is outside of the entrypoint directory, we do
-        // not want to monitor it for changes.
-        if (!pathIsInside(entryDirectory, file)) {
-            continue;
-        }
-        watch.push(file);
-    }
-    return watch;
-}
-exports.getPathsInside = getPathsInside;
 function normalizePage(page) {
     // Resolve on anything that doesn't start with `/`
     if (!page.startsWith('/')) {
@@ -142,95 +136,6 @@ function normalizePage(page) {
     return page;
 }
 exports.normalizePage = normalizePage;
-async function getRoutes(entryPath, entryDirectory, pathsInside, files, url) {
-    let pagesDir = '';
-    const filesInside = {};
-    const prefix = entryDirectory === `.` ? `/` : `/${entryDirectory}/`;
-    const fileKeys = Object.keys(files);
-    for (const file of fileKeys) {
-        if (!pathsInside.includes(file)) {
-            continue;
-        }
-        if (!pagesDir) {
-            if (file.startsWith(path_1.default.join(entryDirectory, 'pages'))) {
-                pagesDir = 'pages';
-            }
-        }
-        filesInside[file] = files[file];
-    }
-    // If default pages dir isn't found check for `src/pages`
-    if (!pagesDir &&
-        fileKeys.some(file => file.startsWith(path_1.default.join(entryDirectory, 'src/pages')))) {
-        pagesDir = 'src/pages';
-    }
-    const routes = [
-        {
-            src: `${prefix}_next/(.*)`,
-            dest: `${url}/_next/$1`,
-        },
-        {
-            src: `${prefix}static/(.*)`,
-            dest: `${url}/static/$1`,
-        },
-    ];
-    const filePaths = Object.keys(filesInside);
-    const dynamicPages = [];
-    for (const file of filePaths) {
-        const relativePath = path_1.default.relative(entryDirectory, file);
-        const isPage = pathIsInside(pagesDir, relativePath);
-        if (!isPage) {
-            continue;
-        }
-        const relativeToPages = path_1.default.relative(pagesDir, relativePath);
-        const extension = path_1.default.extname(relativeToPages);
-        const pageName = relativeToPages.replace(extension, '').replace(/\\/g, '/');
-        if (pageName.startsWith('_')) {
-            continue;
-        }
-        if (isDynamicRoute(pageName)) {
-            dynamicPages.push(normalizePage(pageName));
-            continue;
-        }
-        routes.push({
-            src: `${prefix}${pageName}`,
-            dest: `${url}/${pageName}`,
-        });
-        if (pageName.endsWith('index')) {
-            const resolvedIndex = pageName.replace('/index', '').replace('index', '');
-            routes.push({
-                src: `${prefix}${resolvedIndex}`,
-                dest: `${url}/${resolvedIndex}`,
-            });
-        }
-    }
-    routes.push(...(await getDynamicRoutes(entryPath, entryDirectory, dynamicPages, true).then(arr => arr.map((route) => {
-        // convert to make entire RegExp match as one group
-        route.src = route.src
-            .replace('^', `^${prefix}(`)
-            .replace('(\\/', '(')
-            .replace('$', ')$');
-        route.dest = `${url}/$1`;
-        return route;
-    }))));
-    // Add public folder routes
-    for (const file of filePaths) {
-        const relativePath = path_1.default.relative(entryDirectory, file);
-        const isPublic = pathIsInside('public', relativePath);
-        if (!isPublic)
-            continue;
-        const fileName = path_1.default.relative('public', relativePath);
-        const route = {
-            src: `${prefix}${fileName}`,
-            dest: `${url}/${fileName}`,
-        };
-        // Only add the route if a page is not already using it
-        if (!routes.some(r => r.src === route.src)) {
-            routes.push(route);
-        }
-    }
-    return routes;
-}
-exports.getRoutes = getRoutes;
 async function getRoutesManifest(entryPath, outputDirectory, nextVersion) {
     const shouldHaveManifest = nextVersion && semver_1.default.gte(nextVersion, '9.1.4-canary.0');
     if (!shouldHaveManifest)
@@ -241,8 +146,8 @@ async function getRoutesManifest(entryPath, outputDirectory, nextVersion) {
         .then(() => true)
         .catch(() => false);
     if (shouldHaveManifest && !hasRoutesManifest) {
-        throw new NowBuildError({
-            message: `A "routes-manifest.json" couldn't be found. This is normally caused by a misconfiguration in your project.\n` +
+        throw new build_utils_1.NowBuildError({
+            message: `The file "${pathRoutesManifest}" couldn't be found. This is normally caused by a misconfiguration in your project.\n` +
                 'Please check the following, and reach out to support if you cannot resolve the problem:\n' +
                 '  1. If present, be sure your `build` script in "package.json" calls `next build`.' +
                 '  2. Navigate to your project\'s settings in the Vercel dashboard, and verify that the "Build Command" is not overridden, or that it calls `next build`.' +
@@ -262,7 +167,7 @@ async function getRoutesManifest(entryPath, outputDirectory, nextVersion) {
         }
     }
     for (const route of routesManifest.dynamicRoutes || []) {
-        if (Array.isArray(route.routeKeys)) {
+        if ('routeKeys' in route && Array.isArray(route.routeKeys)) {
             delete route.routeKeys;
             delete route.namedRegex;
         }
@@ -270,42 +175,67 @@ async function getRoutesManifest(entryPath, outputDirectory, nextVersion) {
     return routesManifest;
 }
 exports.getRoutesManifest = getRoutesManifest;
-async function getDynamicRoutes(entryPath, entryDirectory, dynamicPages, isDev, routesManifest, omittedRoutes) {
-    if (!dynamicPages.length) {
-        return [];
-    }
+async function getDynamicRoutes(entryPath, entryDirectory, dynamicPages, isDev, routesManifest, omittedRoutes, canUsePreviewMode, bypassToken, isServerMode, dynamicMiddlewareRouteMap) {
     if (routesManifest) {
         switch (routesManifest.version) {
             case 1:
             case 2: {
                 return routesManifest.dynamicRoutes
-                    .filter(({ page }) => omittedRoutes ? !omittedRoutes.has(page) : true)
+                    .filter(({ page }) => canUsePreviewMode || !(omittedRoutes === null || omittedRoutes === void 0 ? void 0 : omittedRoutes.has(page)))
                     .map(({ page, regex }) => {
                     return {
                         src: regex,
                         dest: !isDev ? path_1.default.join('/', entryDirectory, page) : page,
                         check: true,
+                        status: canUsePreviewMode && (omittedRoutes === null || omittedRoutes === void 0 ? void 0 : omittedRoutes.has(page)) ? 404 : undefined,
                     };
                 });
             }
-            case 3: {
+            case 3:
+            case 4: {
                 return routesManifest.dynamicRoutes
-                    .filter(({ page }) => omittedRoutes ? !omittedRoutes.has(page) : true)
-                    .map(({ page, namedRegex, regex, routeKeys }) => {
-                    return {
+                    .filter(({ page }) => canUsePreviewMode || !(omittedRoutes === null || omittedRoutes === void 0 ? void 0 : omittedRoutes.has(page)))
+                    .map(params => {
+                    if ('isMiddleware' in params) {
+                        const route = dynamicMiddlewareRouteMap === null || dynamicMiddlewareRouteMap === void 0 ? void 0 : dynamicMiddlewareRouteMap.get(params.page);
+                        if (!route) {
+                            throw new Error(`Could not find dynamic middleware route for ${params.page}`);
+                        }
+                        return route;
+                    }
+                    const { page, namedRegex, regex, routeKeys } = params;
+                    const route = {
                         src: namedRegex || regex,
                         dest: `${!isDev ? path_1.default.join('/', entryDirectory, page) : page}${routeKeys
                             ? `?${Object.keys(routeKeys)
                                 .map(key => `${routeKeys[key]}=$${key}`)
                                 .join('&')}`
                             : ''}`,
-                        check: true,
                     };
+                    if (!isServerMode) {
+                        route.check = true;
+                    }
+                    if (isServerMode && canUsePreviewMode && (omittedRoutes === null || omittedRoutes === void 0 ? void 0 : omittedRoutes.has(page))) {
+                        // only match this route when in preview mode so
+                        // preview works for non-prerender fallback: false pages
+                        route.has = [
+                            {
+                                type: 'cookie',
+                                key: '__prerender_bypass',
+                                value: bypassToken || undefined,
+                            },
+                            {
+                                type: 'cookie',
+                                key: '__next_preview_data',
+                            },
+                        ];
+                    }
+                    return route;
                 });
             }
             default: {
                 // update MIN_ROUTES_MANIFEST_VERSION
-                throw new NowBuildError({
+                throw new build_utils_1.NowBuildError({
                     message: 'This version of `@vercel/next` does not support the version of Next.js you are trying to deploy.\n' +
                         'Please upgrade your `@vercel/next` builder and try again. Contact support if this continues to happen.',
                     code: 'NEXT_VERSION_UPGRADE',
@@ -316,10 +246,13 @@ async function getDynamicRoutes(entryPath, entryDirectory, dynamicPages, isDev,
     // FALLBACK:
     // When `routes-manifest.json` does not exist (old Next.js versions), we'll try to
     // require the methods we need from Next.js' internals.
+    if (!dynamicPages.length) {
+        return [];
+    }
     let getRouteRegex = undefined;
     let getSortedRoutes;
     try {
-        ({ getRouteRegex, getSortedRoutes } = require(resolve_from_1.default(entryPath, 'next-server/dist/lib/router/utils')));
+        ({ getRouteRegex, getSortedRoutes } = require((0, resolve_from_1.default)(entryPath, 'next-server/dist/lib/router/utils')));
         if (typeof getRouteRegex !== 'function') {
             getRouteRegex = undefined;
         }
@@ -327,7 +260,7 @@ async function getDynamicRoutes(entryPath, entryDirectory, dynamicPages, isDev,
     catch (_) { } // eslint-disable-line no-empty
     if (!getRouteRegex || !getSortedRoutes) {
         try {
-            ({ getRouteRegex, getSortedRoutes } = require(resolve_from_1.default(entryPath, 'next/dist/next-server/lib/router/utils')));
+            ({ getRouteRegex, getSortedRoutes } = require((0, resolve_from_1.default)(entryPath, 'next/dist/next-server/lib/router/utils')));
             if (typeof getRouteRegex !== 'function') {
                 getRouteRegex = undefined;
             }
@@ -335,7 +268,7 @@ async function getDynamicRoutes(entryPath, entryDirectory, dynamicPages, isDev,
         catch (_) { } // eslint-disable-line no-empty
     }
     if (!getRouteRegex || !getSortedRoutes) {
-        throw new NowBuildError({
+        throw new build_utils_1.NowBuildError({
             message: 'Found usage of dynamic routes but not on a new enough version of Next.js.',
             code: 'NEXT_DYNAMIC_ROUTES_OUTDATED',
         });
@@ -361,6 +294,34 @@ async function getDynamicRoutes(entryPath, entryDirectory, dynamicPages, isDev,
     return routes;
 }
 exports.getDynamicRoutes = getDynamicRoutes;
+function localizeDynamicRoutes(dynamicRoutes, dynamicPrefix, entryDirectory, staticPages, prerenderManifest, routesManifest, isServerMode, isCorrectLocaleAPIRoutes) {
+    return dynamicRoutes.map((route) => {
+        // i18n is already handled for middleware
+        if (route.middleware !== undefined || route.middlewarePath !== undefined)
+            return route;
+        const { i18n } = routesManifest || {};
+        if (i18n) {
+            const { pathname } = url_1.default.parse(route.dest);
+            const pathnameNoPrefix = pathname === null || pathname === void 0 ? void 0 : pathname.replace(dynamicPrefix, '');
+            const isFallback = prerenderManifest.fallbackRoutes[pathname];
+            const isBlocking = prerenderManifest.blockingFallbackRoutes[pathname];
+            const isApiRoute = pathnameNoPrefix === '/api' || (pathnameNoPrefix === null || pathnameNoPrefix === void 0 ? void 0 : pathnameNoPrefix.startsWith('/api/'));
+            const isAutoExport = staticPages[addLocaleOrDefault(pathname, routesManifest).substr(1)];
+            const isLocalePrefixed = isFallback || isBlocking || isAutoExport || isServerMode;
+            route.src = route.src.replace('^', `^${dynamicPrefix ? `${dynamicPrefix}[/]?` : '[/]?'}(?${isLocalePrefixed ? '<nextLocale>' : ':'}${i18n.locales.map(locale => (0, escape_string_regexp_1.default)(locale)).join('|')})?`);
+            if (isLocalePrefixed && !(isCorrectLocaleAPIRoutes && isApiRoute)) {
+                // ensure destination has locale prefix to match prerender output
+                // path so that the prerender object is used
+                route.dest = route.dest.replace(`${path_1.default.join('/', entryDirectory, '/')}`, `${path_1.default.join('/', entryDirectory, '$nextLocale', '/')}`);
+            }
+        }
+        else {
+            route.src = route.src.replace('^', `^${dynamicPrefix}`);
+        }
+        return route;
+    });
+}
+exports.localizeDynamicRoutes = localizeDynamicRoutes;
 async function getImagesManifest(entryPath, outputDirectory) {
     const pathImagesManifest = path_1.default.join(entryPath, outputDirectory, 'images-manifest.json');
     const hasImagesManifest = await fs_extra_1.default
@@ -375,19 +336,90 @@ async function getImagesManifest(entryPath, outputDirectory) {
     return imagesManifest;
 }
 exports.getImagesManifest = getImagesManifest;
-function syncEnvVars(base, removeEnv, addEnv) {
-    // Remove any env vars from `removeEnv`
-    // that are not present in the `addEnv`
-    const addKeys = new Set(Object.keys(addEnv));
-    for (const name of Object.keys(removeEnv)) {
-        if (!addKeys.has(name)) {
-            delete base[name];
+function filterStaticPages(staticPageFiles, dynamicPages, entryDirectory, htmlContentType, prerenderManifest, routesManifest) {
+    const staticPages = {};
+    Object.keys(staticPageFiles).forEach((page) => {
+        var _a;
+        const pathname = page.replace(/\.html$/, '');
+        const routeName = normalizeLocalePath(normalizePage(pathname), (_a = routesManifest === null || routesManifest === void 0 ? void 0 : routesManifest.i18n) === null || _a === void 0 ? void 0 : _a.locales).pathname;
+        // Prerendered routes emit a `.html` file but should not be treated as a
+        // static page.
+        // Lazily prerendered routes have a fallback `.html` file on newer
+        // Next.js versions so we need to also not treat it as a static page here.
+        if (prerenderManifest.staticRoutes[routeName] ||
+            prerenderManifest.fallbackRoutes[routeName] ||
+            prerenderManifest.staticRoutes[normalizePage(pathname)] ||
+            prerenderManifest.fallbackRoutes[normalizePage(pathname)]) {
+            return;
+        }
+        const staticRoute = path_1.default.join(entryDirectory, pathname);
+        staticPages[staticRoute] = staticPageFiles[page];
+        staticPages[staticRoute].contentType = htmlContentType;
+        if (isDynamicRoute(pathname)) {
+            dynamicPages.push(routeName);
+            return;
+        }
+    });
+    return staticPages;
+}
+exports.filterStaticPages = filterStaticPages;
+function getFilesMapFromReasons(fileList, reasons, ignoreFn) {
+    // this uses the reasons tree to collect files specific to a
+    // certain parent allowing us to not have to trace each parent
+    // separately
+    const parentFilesMap = new Map();
+    function propagateToParents(parents, file, seen = new Set()) {
+        for (const parent of parents || []) {
+            if (!seen.has(parent)) {
+                seen.add(parent);
+                let parentFiles = parentFilesMap.get(parent);
+                if (!parentFiles) {
+                    parentFiles = new Set();
+                    parentFilesMap.set(parent, parentFiles);
+                }
+                if (!(ignoreFn === null || ignoreFn === void 0 ? void 0 : ignoreFn(file, parent))) {
+                    parentFiles.add(file);
+                }
+                const parentReason = reasons.get(parent);
+                if (parentReason === null || parentReason === void 0 ? void 0 : parentReason.parents) {
+                    propagateToParents(parentReason.parents, file, seen);
+                }
+            }
         }
     }
-    // Add in the keys from `addEnv`
-    Object.assign(base, addEnv);
+    for (const file of fileList) {
+        const reason = reasons.get(file);
+        const isInitial = (reason === null || reason === void 0 ? void 0 : reason.type.length) === 1 && reason.type.includes('initial');
+        if (!reason ||
+            !reason.parents ||
+            (isInitial && reason.parents.size === 0)) {
+            continue;
+        }
+        propagateToParents(reason.parents, file);
+    }
+    return parentFilesMap;
 }
-exports.syncEnvVars = syncEnvVars;
+exports.getFilesMapFromReasons = getFilesMapFromReasons;
+const collectTracedFiles = (baseDir, lstatResults, lstatSema, reasons, files) => async (file) => {
+    const reason = reasons.get(file);
+    if (reason && reason.type.includes('initial')) {
+        // Initial files are manually added to the lambda later
+        return;
+    }
+    const filePath = path_1.default.join(baseDir, file);
+    if (!lstatResults[filePath]) {
+        lstatResults[filePath] = lstatSema
+            .acquire()
+            .then(() => (0, fs_extra_1.lstat)(filePath))
+            .finally(() => lstatSema.release());
+    }
+    const { mode } = await lstatResults[filePath];
+    files[file] = new build_utils_1.FileFsRef({
+        fsPath: path_1.default.join(baseDir, file),
+        mode,
+    });
+};
+exports.collectTracedFiles = collectTracedFiles;
 exports.ExperimentalTraceVersion = `9.0.4-canary.1`;
 const compressBuffer = (buf) => {
     return new Promise((resolve, reject) => {
@@ -403,7 +435,7 @@ async function createPseudoLayer(files) {
     let pseudoLayerBytes = 0;
     for (const fileName of Object.keys(files)) {
         const file = files[fileName];
-        if (isSymbolicLink(file.mode)) {
+        if ((0, build_utils_1.isSymbolicLink)(file.mode)) {
             const symlinkTarget = await fs_extra_1.default.readlink(file.fsPath);
             pseudoLayer[fileName] = {
                 file,
@@ -412,15 +444,15 @@ async function createPseudoLayer(files) {
             };
         }
         else {
-            const origBuffer = await streamToBuffer(file.toStream());
+            const origBuffer = await (0, build_utils_1.streamToBuffer)(file.toStream());
             const compBuffer = await compressBuffer(origBuffer);
             pseudoLayerBytes += compBuffer.byteLength;
             pseudoLayer[fileName] = {
+                file,
                 compBuffer,
                 isSymlink: false,
                 crc32: buffer_crc32_1.default.unsigned(origBuffer),
                 uncompressedSize: origBuffer.byteLength,
-                mode: file.mode,
             };
         }
     }
@@ -430,66 +462,38 @@ exports.createPseudoLayer = createPseudoLayer;
 // measured with 1, 2, 5, 10, and `os.cpus().length || 5`
 // and sema(1) produced the best results
 const createLambdaSema = new async_sema_1.Sema(1);
-async function createLambdaFromPseudoLayers({ files, layers, handler, runtime, memory, maxDuration, environment = {}, }) {
+async function createLambdaFromPseudoLayers({ files: baseFiles, layers, ...lambdaOptions }) {
     await createLambdaSema.acquire();
-    const zipFile = new yazl_1.ZipFile();
+    const files = {};
     const addedFiles = new Set();
-    const names = Object.keys(files).sort();
-    const symlinkTargets = new Map();
-    for (const name of names) {
-        const file = files[name];
-        if (file.mode && isSymbolicLink(file.mode) && file.type === 'FileFsRef') {
-            const symlinkTarget = await fs_extra_1.default.readlink(file.fsPath);
-            symlinkTargets.set(name, symlinkTarget);
-        }
-    }
-    // apply pseudo layers (already compressed objects)
+    // Add files from pseudo layers
     for (const layer of layers) {
         for (const seedKey of Object.keys(layer)) {
-            const item = layer[seedKey];
-            if (item.isSymlink) {
-                const { symlinkTarget, file } = item;
-                zipFile.addBuffer(Buffer.from(symlinkTarget, 'utf8'), seedKey, {
-                    mode: file.mode,
-                });
+            if (addedFiles.has(seedKey)) {
+                // File was already added in a previous pseudo layer
                 continue;
             }
-            const { compBuffer, crc32, uncompressedSize, mode } = item;
-            // @ts-ignore: `addDeflatedBuffer` is a valid function, but missing on the type
-            zipFile.addDeflatedBuffer(compBuffer, seedKey, {
-                crc32,
-                uncompressedSize,
-                mode: mode,
-            });
+            const item = layer[seedKey];
+            files[seedKey] = item.file;
             addedFiles.add(seedKey);
         }
     }
-    for (const fileName of Object.keys(files)) {
-        // was already added in a pseudo layer
-        if (addedFiles.has(fileName))
+    for (const fileName of Object.keys(baseFiles)) {
+        if (addedFiles.has(fileName)) {
+            // File was already added in a previous pseudo layer
             continue;
-        const file = files[fileName];
-        const symlinkTarget = symlinkTargets.get(fileName);
-        if (typeof symlinkTarget === 'string') {
-            zipFile.addBuffer(Buffer.from(symlinkTarget, 'utf8'), fileName, {
-                mode: file.mode,
-            });
-        }
-        else {
-            const fileBuffer = await streamToBuffer(file.toStream());
-            zipFile.addBuffer(fileBuffer, fileName);
         }
+        const file = baseFiles[fileName];
+        files[fileName] = file;
+        addedFiles.add(fileName);
     }
-    zipFile.end();
-    const zipBuffer = await streamToBuffer(zipFile.outputStream);
     createLambdaSema.release();
-    return new Lambda({
-        handler,
-        runtime,
-        zipBuffer,
-        memory,
-        maxDuration,
-        environment,
+    return new build_utils_1.NodejsLambda({
+        ...lambdaOptions,
+        files,
+        shouldAddHelpers: false,
+        shouldAddSourcemapSupport: false,
+        supportsMultiPayloads: !!process.env.NEXT_PRIVATE_MULTI_PAYLOAD,
     });
 }
 exports.createLambdaFromPseudoLayers = createLambdaFromPseudoLayers;
@@ -539,6 +543,37 @@ async function getExportStatus(entryPath) {
     }
 }
 exports.getExportStatus = getExportStatus;
+async function getRequiredServerFilesManifest(entryPath, outputDirectory) {
+    const pathRequiredServerFilesManifest = path_1.default.join(entryPath, outputDirectory, 'required-server-files.json');
+    const hasManifest = await fs_extra_1.default
+        .access(pathRequiredServerFilesManifest, fs_extra_1.default.constants.F_OK)
+        .then(() => true)
+        .catch(() => false);
+    if (!hasManifest) {
+        return false;
+    }
+    const manifestData = JSON.parse(await fs_extra_1.default.readFile(pathRequiredServerFilesManifest, 'utf8'));
+    const requiredServerFiles = {
+        files: [],
+        ignore: [],
+        config: {},
+        appDir: manifestData.appDir,
+    };
+    switch (manifestData.version) {
+        case 1: {
+            requiredServerFiles.files = manifestData.files;
+            requiredServerFiles.ignore = manifestData.ignore;
+            requiredServerFiles.config = manifestData.config;
+            requiredServerFiles.appDir = manifestData.appDir;
+            break;
+        }
+        default: {
+            throw new Error(`Invalid required-server-files manifest version ${manifestData.version}, please contact support if this error persists`);
+        }
+    }
+    return requiredServerFiles;
+}
+exports.getRequiredServerFilesManifest = getRequiredServerFilesManifest;
 async function getPrerenderManifest(entryPath, outputDirectory) {
     const pathPrerenderManifest = path_1.default.join(entryPath, outputDirectory, 'prerender-manifest.json');
     const hasManifest = await fs_extra_1.default
@@ -551,8 +586,9 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
             blockingFallbackRoutes: {},
             fallbackRoutes: {},
             bypassToken: null,
-            omittedRoutes: [],
+            omittedRoutes: {},
             notFoundRoutes: [],
+            isLocalePrefixed: false,
         };
     }
     const manifest = JSON.parse(await fs_extra_1.default.readFile(pathPrerenderManifest, 'utf8'));
@@ -565,11 +601,12 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
                 blockingFallbackRoutes: {},
                 fallbackRoutes: {},
                 bypassToken: (manifest.preview && manifest.preview.previewModeId) || null,
-                omittedRoutes: [],
+                omittedRoutes: {},
                 notFoundRoutes: [],
+                isLocalePrefixed: false,
             };
             routes.forEach(route => {
-                const { initialRevalidateSeconds, dataRoute, srcRoute, } = manifest.routes[route];
+                const { initialRevalidateSeconds, dataRoute, srcRoute } = manifest.routes[route];
                 ret.staticRoutes[route] = {
                     initialRevalidate: initialRevalidateSeconds === false
                         ? false
@@ -579,7 +616,7 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
                 };
             });
             lazyRoutes.forEach(lazyRoute => {
-                const { routeRegex, fallback, dataRoute, dataRouteRegex, } = manifest.dynamicRoutes[lazyRoute];
+                const { routeRegex, fallback, dataRoute, dataRouteRegex } = manifest.dynamicRoutes[lazyRoute];
                 if (fallback) {
                     ret.fallbackRoutes[lazyRoute] = {
                         routeRegex,
@@ -598,7 +635,8 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
             });
             return ret;
         }
-        case 2: {
+        case 2:
+        case 3: {
             const routes = Object.keys(manifest.routes);
             const lazyRoutes = Object.keys(manifest.dynamicRoutes);
             const ret = {
@@ -606,14 +644,15 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
                 blockingFallbackRoutes: {},
                 fallbackRoutes: {},
                 bypassToken: manifest.preview.previewModeId,
-                omittedRoutes: [],
+                omittedRoutes: {},
                 notFoundRoutes: [],
+                isLocalePrefixed: manifest.version > 2,
             };
             if (manifest.notFoundRoutes) {
                 ret.notFoundRoutes.push(...manifest.notFoundRoutes);
             }
             routes.forEach(route => {
-                const { initialRevalidateSeconds, dataRoute, srcRoute, } = manifest.routes[route];
+                const { initialRevalidateSeconds, dataRoute, srcRoute } = manifest.routes[route];
                 ret.staticRoutes[route] = {
                     initialRevalidate: initialRevalidateSeconds === false
                         ? false
@@ -623,7 +662,7 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
                 };
             });
             lazyRoutes.forEach(lazyRoute => {
-                const { routeRegex, fallback, dataRoute, dataRouteRegex, } = manifest.dynamicRoutes[lazyRoute];
+                const { routeRegex, fallback, dataRoute, dataRouteRegex } = manifest.dynamicRoutes[lazyRoute];
                 if (typeof fallback === 'string') {
                     ret.fallbackRoutes[lazyRoute] = {
                         routeRegex,
@@ -642,7 +681,11 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
                 else {
                     // Fallback behavior is disabled, all routes would've been provided
                     // in the top-level `routes` key (`staticRoutes`).
-                    ret.omittedRoutes.push(lazyRoute);
+                    ret.omittedRoutes[lazyRoute] = {
+                        routeRegex,
+                        dataRoute,
+                        dataRouteRegex,
+                    };
                 }
             });
             return ret;
@@ -653,8 +696,9 @@ async function getPrerenderManifest(entryPath, outputDirectory) {
                 blockingFallbackRoutes: {},
                 fallbackRoutes: {},
                 bypassToken: null,
-                omittedRoutes: [],
+                omittedRoutes: {},
                 notFoundRoutes: [],
+                isLocalePrefixed: false,
             };
         }
     }
@@ -676,10 +720,10 @@ async function usesSrcDirectory(workPath) {
     }
     return Boolean(_usesSrcCache);
 }
-async function getSourceFilePathFromPage({ workPath, page, }) {
+async function getSourceFilePathFromPage({ workPath, page, pageExtensions, }) {
     // TODO: this should be updated to get the pageExtensions
     // value used during next build
-    const extensionsToTry = ['.js', '.jsx', '.ts', '.tsx'];
+    const extensionsToTry = pageExtensions || ['js', 'jsx', 'ts', 'tsx'];
     let fsPath = path_1.default.join(workPath, 'pages', page);
     if (await usesSrcDirectory(workPath)) {
         fsPath = path_1.default.join(workPath, 'src', 'pages', page);
@@ -689,20 +733,20 @@ async function getSourceFilePathFromPage({ workPath, page, }) {
     }
     const extensionless = fsPath.slice(0, -3); // remove ".js"
     for (const ext of extensionsToTry) {
-        fsPath = extensionless + ext;
+        fsPath = `${extensionless}.${ext}`;
         if (fs_extra_1.default.existsSync(fsPath)) {
             return path_1.default.relative(workPath, fsPath);
         }
     }
     if (isDirectory(extensionless)) {
         for (const ext of extensionsToTry) {
-            fsPath = path_1.default.join(extensionless, 'index' + ext);
+            fsPath = path_1.default.join(extensionless, `index.${ext}`);
             if (fs_extra_1.default.existsSync(fsPath)) {
                 return path_1.default.relative(workPath, fsPath);
             }
         }
     }
-    console.log(`WARNING: Unable to find source file for page ${page}`);
+    console.log(`WARNING: Unable to find source file for page ${page} with extensions: ${extensionsToTry.join(', ')}, this can cause functions config from \`vercel.json\` to not be applied`);
     return '';
 }
 exports.getSourceFilePathFromPage = getSourceFilePathFromPage;
@@ -738,3 +782,704 @@ function addLocaleOrDefault(pathname, routesManifest, locale) {
         : pathname;
 }
 exports.addLocaleOrDefault = addLocaleOrDefault;
+exports.MAX_UNCOMPRESSED_LAMBDA_SIZE = 250 * 1000 * 1000; // 250MB
+const LAMBDA_RESERVED_UNCOMPRESSED_SIZE = 2.5 * 1000 * 1000; // 2.5MB
+const LAMBDA_RESERVED_COMPRESSED_SIZE = 250 * 1000; // 250KB
+async function getPageLambdaGroups(entryPath, config, pages, prerenderRoutes, pageTraces, compressedPages, tracedPseudoLayer, initialPseudoLayerSize, initialPseudoLayerUncompressedSize, lambdaCompressedByteLimit, internalPages, pageExtensions) {
+    const groups = [];
+    for (const page of pages) {
+        const newPages = [...internalPages, page];
+        const routeName = normalizePage(page.replace(/\.js$/, ''));
+        const isPrerenderRoute = prerenderRoutes.has(routeName);
+        let opts = {};
+        if (config && config.functions) {
+            const sourceFile = await getSourceFilePathFromPage({
+                workPath: entryPath,
+                page,
+                pageExtensions,
+            });
+            opts = await (0, build_utils_1.getLambdaOptionsFromFunction)({
+                sourceFile,
+                config,
+            });
+        }
+        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;
+                for (const newPage of newPages) {
+                    Object.keys(pageTraces[newPage] || {}).map(file => {
+                        var _a;
+                        if (!group.pseudoLayer[file]) {
+                            const item = tracedPseudoLayer[file];
+                            newTracedFilesSize += ((_a = item.compBuffer) === null || _a === void 0 ? void 0 : _a.byteLength) || 0;
+                            newTracedFilesUncompressedSize += item.uncompressedSize || 0;
+                        }
+                    });
+                    newTracedFilesSize += compressedPages[newPage].compBuffer.byteLength;
+                    newTracedFilesUncompressedSize +=
+                        compressedPages[newPage].uncompressedSize;
+                }
+                const underUncompressedLimit = newTracedFilesUncompressedSize + initialPseudoLayerUncompressedSize <
+                    exports.MAX_UNCOMPRESSED_LAMBDA_SIZE - LAMBDA_RESERVED_UNCOMPRESSED_SIZE;
+                const underCompressedLimit = newTracedFilesSize + initialPseudoLayerSize <
+                    lambdaCompressedByteLimit - LAMBDA_RESERVED_COMPRESSED_SIZE;
+                return underUncompressedLimit && underCompressedLimit;
+            }
+            return false;
+        });
+        if (matchingGroup) {
+            matchingGroup.pages.push(page);
+        }
+        else {
+            const newGroup = {
+                pages: [page],
+                ...opts,
+                isPrerenders: isPrerenderRoute,
+                pseudoLayerBytes: 0,
+                pseudoLayerUncompressedBytes: 0,
+                pseudoLayer: {},
+            };
+            groups.push(newGroup);
+            matchingGroup = newGroup;
+        }
+        for (const newPage of newPages) {
+            Object.keys(pageTraces[newPage] || {}).map(file => {
+                var _a;
+                const pseudoItem = tracedPseudoLayer[file];
+                const compressedSize = ((_a = pseudoItem === null || pseudoItem === void 0 ? void 0 : pseudoItem.compBuffer) === null || _a === void 0 ? void 0 : _a.byteLength) || 0;
+                if (!matchingGroup.pseudoLayer[file]) {
+                    matchingGroup.pseudoLayer[file] = pseudoItem;
+                    matchingGroup.pseudoLayerBytes += compressedSize;
+                    matchingGroup.pseudoLayerUncompressedBytes +=
+                        pseudoItem.uncompressedSize || 0;
+                }
+            });
+            // ensure the page file itself is accounted for when grouping as
+            // large pages can be created that can push the group over the limit
+            matchingGroup.pseudoLayerBytes +=
+                compressedPages[newPage].compBuffer.byteLength;
+            matchingGroup.pseudoLayerUncompressedBytes +=
+                compressedPages[newPage].uncompressedSize;
+        }
+    }
+    return groups;
+}
+exports.getPageLambdaGroups = getPageLambdaGroups;
+const 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',
+        'Compressed size',
+    ]);
+    const dependencies = {};
+    for (const fileKey of Object.keys(pseudoLayer)) {
+        if (!pseudoLayer[fileKey].isSymlink) {
+            const fileItem = pseudoLayer[fileKey];
+            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,
+        };
+    }
+    let numLargeDependencies = 0;
+    Object.keys(dependencies)
+        .sort((a, b) => {
+        // move largest dependencies to the top
+        const aDep = dependencies[a];
+        const bDep = dependencies[b];
+        if (aDep.compressed > bDep.compressed) {
+            return -1;
+        }
+        if (aDep.compressed < bDep.compressed) {
+            return 1;
+        }
+        return 0;
+    })
+        .forEach(depKey => {
+        const dep = dependencies[depKey];
+        if (dep.compressed < 100 * 1000 && dep.uncompressed < 500 * 1000) {
+            // ignore smaller dependencies to reduce noise
+            return;
+        }
+        exceededLimitOutput.push([
+            depKey,
+            (0, pretty_bytes_1.default)(dep.uncompressed),
+            (0, pretty_bytes_1.default)(dep.compressed),
+        ]);
+        numLargeDependencies += 1;
+    });
+    if (numLargeDependencies === 0) {
+        exceededLimitOutput.push([
+            'No large dependencies found (> 100KB compressed)',
+        ]);
+    }
+    exceededLimitOutput.push([]);
+    exceededLimitOutput.push([
+        'All dependencies',
+        (0, pretty_bytes_1.default)(pseudoLayerUncompressedBytes),
+        (0, pretty_bytes_1.default)(pseudoLayerBytes),
+    ]);
+    console.log((0, text_table_1.default)(exceededLimitOutput, {
+        align: ['l', 'r', 'r'],
+    }));
+};
+exports.outputFunctionFileSizeInfo = outputFunctionFileSizeInfo;
+const detectLambdaLimitExceeding = async (lambdaGroups, compressedSizeLimit, compressedPages) => {
+    // show debug info if within 5 MB of exceeding the limit
+    const COMPRESSED_SIZE_LIMIT_CLOSE = compressedSizeLimit - 5 * 1000 * 1000;
+    const UNCOMPRESSED_SIZE_LIMIT_CLOSE = exports.MAX_UNCOMPRESSED_LAMBDA_SIZE - 5 * 1000 * 1000;
+    let numExceededLimit = 0;
+    let numCloseToLimit = 0;
+    let loggedHeadInfo = false;
+    // pre-iterate to see if we are going to exceed the limit
+    // or only get close so our first log line can be correct
+    const filteredGroups = lambdaGroups.filter(group => {
+        const exceededLimit = group.pseudoLayerBytes > compressedSizeLimit ||
+            group.pseudoLayerUncompressedBytes > exports.MAX_UNCOMPRESSED_LAMBDA_SIZE;
+        const closeToLimit = group.pseudoLayerBytes > COMPRESSED_SIZE_LIMIT_CLOSE ||
+            group.pseudoLayerUncompressedBytes > UNCOMPRESSED_SIZE_LIMIT_CLOSE;
+        if (closeToLimit ||
+            exceededLimit ||
+            (0, build_utils_1.getPlatformEnv)('BUILDER_DEBUG') ||
+            process.env.NEXT_DEBUG_FUNCTION_SIZE) {
+            if (exceededLimit) {
+                numExceededLimit += 1;
+            }
+            if (closeToLimit) {
+                numCloseToLimit += 1;
+            }
+            return true;
+        }
+    });
+    for (const group of filteredGroups) {
+        if (!loggedHeadInfo) {
+            if (numExceededLimit || numCloseToLimit) {
+                console.log(`Warning: Max serverless function size of ${(0, pretty_bytes_1.default)(compressedSizeLimit)} compressed or ${(0, pretty_bytes_1.default)(exports.MAX_UNCOMPRESSED_LAMBDA_SIZE)} uncompressed${numExceededLimit ? '' : ' almost'} reached`);
+            }
+            else {
+                console.log(`Serverless function size info`);
+            }
+            loggedHeadInfo = true;
+        }
+        (0, exports.outputFunctionFileSizeInfo)(group.pages, group.pseudoLayer, group.pseudoLayerBytes, group.pseudoLayerUncompressedBytes, compressedPages);
+    }
+    if (numExceededLimit) {
+        console.log(`Max serverless function size was exceeded for ${numExceededLimit} function${numExceededLimit === 1 ? '' : 's'}`);
+    }
+};
+exports.detectLambdaLimitExceeding = detectLambdaLimitExceeding;
+// checks if prerender files are all static or not before creating lambdas
+const onPrerenderRouteInitial = (prerenderManifest, canUsePreviewMode, entryDirectory, nonLambdaSsgPages, routeKey, hasPages404, routesManifest) => {
+    let static404Page;
+    let static500Page;
+    // Get the route file as it'd be mounted in the builder output
+    const pr = prerenderManifest.staticRoutes[routeKey];
+    const { initialRevalidate, srcRoute } = pr;
+    const route = srcRoute || routeKey;
+    const routeNoLocale = (routesManifest === null || routesManifest === void 0 ? void 0 : routesManifest.i18n)
+        ? normalizeLocalePath(routeKey, routesManifest.i18n.locales).pathname
+        : routeKey;
+    // if the 404 page used getStaticProps we need to update static404Page
+    // since it wasn't populated from the staticPages group
+    if (routeNoLocale === '/404') {
+        static404Page = path_1.default.join(entryDirectory, routeKey);
+    }
+    if (routeNoLocale === '/500') {
+        static500Page = path_1.default.join(entryDirectory, routeKey);
+    }
+    if (initialRevalidate === false &&
+        (!canUsePreviewMode || (hasPages404 && routeNoLocale === '/404')) &&
+        !prerenderManifest.fallbackRoutes[route] &&
+        !prerenderManifest.blockingFallbackRoutes[route]) {
+        if ((routesManifest === null || routesManifest === void 0 ? void 0 : routesManifest.i18n) &&
+            Object.keys(prerenderManifest.staticRoutes).some(route => {
+                const staticRoute = prerenderManifest.staticRoutes[route];
+                return (staticRoute.srcRoute === srcRoute &&
+                    staticRoute.initialRevalidate !== false);
+            })) {
+            // if any locale static routes are using revalidate the page
+            // requires a lambda
+            return {
+                static404Page,
+                static500Page,
+            };
+        }
+        nonLambdaSsgPages.add(route === '/' ? '/index' : route);
+    }
+    return {
+        static404Page,
+        static500Page,
+    };
+};
+exports.onPrerenderRouteInitial = onPrerenderRouteInitial;
+let prerenderGroup = 1;
+const onPrerenderRoute = (prerenderRouteArgs) => (routeKey, { isBlocking, isFallback, isOmitted, locale, }) => {
+    var _a;
+    const { pagesDir, hasPages404, static404Page, entryDirectory, prerenderManifest, isSharedLambdas, isServerMode, canUsePreviewMode, lambdas, prerenders, pageLambdaMap, routesManifest, isCorrectNotFoundRoutes, } = prerenderRouteArgs;
+    if (isBlocking && isFallback) {
+        throw new build_utils_1.NowBuildError({
+            code: 'NEXT_ISBLOCKING_ISFALLBACK',
+            message: 'invariant: isBlocking and isFallback cannot both be true',
+        });
+    }
+    if (isFallback && isOmitted) {
+        throw new build_utils_1.NowBuildError({
+            code: 'NEXT_ISOMITTED_ISFALLBACK',
+            message: 'invariant: isOmitted and isFallback cannot both be true',
+        });
+    }
+    // Get the route file as it'd be mounted in the builder output
+    let routeFileNoExt = routeKey === '/' ? '/index' : routeKey;
+    let origRouteFileNoExt = routeFileNoExt;
+    const { isLocalePrefixed } = prerenderManifest;
+    if (!locale && isLocalePrefixed) {
+        const localePathResult = normalizeLocalePath(routeKey, ((_a = routesManifest === null || routesManifest === void 0 ? void 0 : routesManifest.i18n) === null || _a === void 0 ? void 0 : _a.locales) || []);
+        locale = localePathResult.detectedLocale;
+        origRouteFileNoExt =
+            localePathResult.pathname === '/'
+                ? '/index'
+                : localePathResult.pathname;
+    }
+    const nonDynamicSsg = !isFallback &&
+        !isBlocking &&
+        !isOmitted &&
+        !prerenderManifest.staticRoutes[routeKey].srcRoute;
+    // if there isn't a srcRoute then it's a non-dynamic SSG page
+    if ((nonDynamicSsg && !isLocalePrefixed) || isFallback || isOmitted) {
+        routeFileNoExt = addLocaleOrDefault(
+        // root index files are located without folder/index.html
+        routeFileNoExt, routesManifest, locale);
+    }
+    const isNotFound = prerenderManifest.notFoundRoutes.includes(routeKey);
+    const htmlFsRef = isBlocking || (isNotFound && !static404Page)
+        ? // Blocking pages do not have an HTML fallback
+            null
+        : new build_utils_1.FileFsRef({
+            fsPath: path_1.default.join(pagesDir, isFallback
+                ? // Fallback pages have a special file.
+                    addLocaleOrDefault(prerenderManifest.fallbackRoutes[routeKey].fallback, routesManifest, locale)
+                : // Otherwise, the route itself should exist as a static HTML
+                    // file.
+                    `${isOmitted || isNotFound
+                        ? addLocaleOrDefault('/404', routesManifest, locale)
+                        : routeFileNoExt}.html`),
+        });
+    const jsonFsRef = 
+    // JSON data does not exist for fallback or blocking pages
+    isFallback || isBlocking || (isNotFound && !static404Page)
+        ? null
+        : new build_utils_1.FileFsRef({
+            fsPath: path_1.default.join(pagesDir, `${isOmitted || isNotFound
+                ? addLocaleOrDefault('/404.html', routesManifest, locale)
+                : routeFileNoExt + '.json'}`),
+        });
+    let initialRevalidate;
+    let srcRoute;
+    let dataRoute;
+    if (isFallback || isBlocking) {
+        const pr = isFallback
+            ? prerenderManifest.fallbackRoutes[routeKey]
+            : prerenderManifest.blockingFallbackRoutes[routeKey];
+        initialRevalidate = 1; // TODO: should Next.js provide this default?
+        // @ts-ignore
+        if (initialRevalidate === false) {
+            // Lazy routes cannot be "snapshotted" in time.
+            throw new build_utils_1.NowBuildError({
+                code: 'NEXT_ISLAZY_INITIALREVALIDATE',
+                message: 'invariant isLazy: initialRevalidate !== false',
+            });
+        }
+        srcRoute = null;
+        dataRoute = pr.dataRoute;
+    }
+    else if (isOmitted) {
+        initialRevalidate = false;
+        srcRoute = routeKey;
+        dataRoute = prerenderManifest.omittedRoutes[routeKey].dataRoute;
+    }
+    else {
+        const pr = prerenderManifest.staticRoutes[routeKey];
+        ({ initialRevalidate, srcRoute, dataRoute } = pr);
+    }
+    const outputPathPage = normalizeIndexOutput(path_1.default.posix.join(entryDirectory, routeFileNoExt), isServerMode);
+    const outputPathPageOrig = path_1.default.posix.join(entryDirectory, origRouteFileNoExt);
+    let lambda;
+    let outputPathData = path_1.default.posix.join(entryDirectory, dataRoute);
+    if (nonDynamicSsg || isFallback || isOmitted) {
+        outputPathData = outputPathData.replace(new RegExp(`${(0, escape_string_regexp_1.default)(origRouteFileNoExt)}.json$`), `${routeFileNoExt}.json`);
+    }
+    if (isSharedLambdas) {
+        const outputSrcPathPage = normalizeIndexOutput(path_1.default.join('/', srcRoute == null
+            ? outputPathPageOrig
+            : path_1.default.join(entryDirectory, srcRoute === '/' ? '/index' : srcRoute)), isServerMode);
+        const lambdaId = pageLambdaMap[outputSrcPathPage];
+        lambda = lambdas[lambdaId];
+    }
+    else {
+        const outputSrcPathPage = normalizeIndexOutput(srcRoute == null
+            ? outputPathPageOrig
+            : path_1.default.posix.join(entryDirectory, srcRoute === '/' ? '/index' : srcRoute), isServerMode);
+        lambda = lambdas[outputSrcPathPage];
+    }
+    if (!isNotFound && initialRevalidate === false) {
+        if (htmlFsRef == null || jsonFsRef == null) {
+            throw new build_utils_1.NowBuildError({
+                code: 'NEXT_HTMLFSREF_JSONFSREF',
+                message: 'invariant: htmlFsRef != null && jsonFsRef != null',
+            });
+        }
+        // If revalidate isn't enabled we force the /404 route to be static
+        // to match next start behavior otherwise getStaticProps would be
+        // recalled for each 404 URL path since Prerender is cached based
+        // on the URL path
+        if (!canUsePreviewMode || (hasPages404 && routeKey === '/404')) {
+            htmlFsRef.contentType = _1.htmlContentType;
+            prerenders[outputPathPage] = htmlFsRef;
+            prerenders[outputPathData] = jsonFsRef;
+        }
+    }
+    const isNotFoundPreview = isCorrectNotFoundRoutes &&
+        !initialRevalidate &&
+        canUsePreviewMode &&
+        isServerMode &&
+        isNotFound;
+    if (prerenders[outputPathPage] == null &&
+        (!isNotFound || initialRevalidate || isNotFoundPreview)) {
+        if (lambda == null) {
+            throw new build_utils_1.NowBuildError({
+                code: 'NEXT_MISSING_LAMBDA',
+                message: `Unable to find lambda for route: ${routeFileNoExt}`,
+            });
+        }
+        // `allowQuery` is an array of query parameter keys that are allowed for
+        // a given path. All other query keys will be striped. We can automatically
+        // detect this for prerender (ISR) pages by reading the routes manifest file.
+        const pageKey = srcRoute || routeKey;
+        const isDynamic = isDynamicRoute(pageKey);
+        const route = routesManifest === null || routesManifest === void 0 ? void 0 : routesManifest.dynamicRoutes.find((r) => r.page === pageKey && !('isMiddleware' in r));
+        const routeKeys = route === null || route === void 0 ? void 0 : route.routeKeys;
+        // by default allowQuery should be undefined and only set when
+        // we have sufficient information to set it
+        let allowQuery;
+        if (routeKeys) {
+            // if we have routeKeys in the routes-manifest we use those
+            // for allowQuery for dynamic routes
+            allowQuery = Object.values(routeKeys);
+        }
+        else if (!isDynamic) {
+            // for non-dynamic routes we use an empty array since
+            // no query values bust the cache for non-dynamic prerenders
+            allowQuery = [];
+        }
+        prerenders[outputPathPage] = new build_utils_1.Prerender({
+            expiration: initialRevalidate,
+            lambda,
+            allowQuery,
+            fallback: htmlFsRef,
+            group: prerenderGroup,
+            bypassToken: prerenderManifest.bypassToken,
+        });
+        prerenders[outputPathData] = new build_utils_1.Prerender({
+            expiration: initialRevalidate,
+            lambda,
+            allowQuery,
+            fallback: jsonFsRef,
+            group: prerenderGroup,
+            bypassToken: prerenderManifest.bypassToken,
+        });
+        ++prerenderGroup;
+        if ((routesManifest === null || routesManifest === void 0 ? void 0 : routesManifest.i18n) && isBlocking) {
+            for (const locale of routesManifest.i18n.locales) {
+                const localeRouteFileNoExt = addLocaleOrDefault(routeFileNoExt, routesManifest, locale);
+                const localeOutputPathPage = normalizeIndexOutput(path_1.default.posix.join(entryDirectory, localeRouteFileNoExt), isServerMode);
+                const localeOutputPathData = outputPathData.replace(new RegExp(`${(0, escape_string_regexp_1.default)(origRouteFileNoExt)}.json$`), `${localeRouteFileNoExt}${localeRouteFileNoExt !== origRouteFileNoExt &&
+                    origRouteFileNoExt === '/index'
+                    ? '/index'
+                    : ''}.json`);
+                const origPrerenderPage = prerenders[outputPathPage];
+                const origPrerenderData = prerenders[outputPathData];
+                prerenders[localeOutputPathPage] = {
+                    ...origPrerenderPage,
+                    group: prerenderGroup,
+                };
+                prerenders[localeOutputPathData] = {
+                    ...origPrerenderData,
+                    group: prerenderGroup,
+                };
+                ++prerenderGroup;
+            }
+        }
+    }
+    if (((nonDynamicSsg && !isLocalePrefixed) || isFallback || isOmitted) &&
+        (routesManifest === null || routesManifest === void 0 ? void 0 : routesManifest.i18n) &&
+        !locale) {
+        // load each locale
+        for (const locale of routesManifest.i18n.locales) {
+            if (locale === routesManifest.i18n.defaultLocale)
+                continue;
+            (0, exports.onPrerenderRoute)(prerenderRouteArgs)(routeKey, {
+                isBlocking,
+                isFallback,
+                isOmitted,
+                locale,
+            });
+        }
+    }
+};
+exports.onPrerenderRoute = onPrerenderRoute;
+async function getStaticFiles(entryPath, entryDirectory, outputDirectory) {
+    const collectLabel = 'Collected static files (public/, static/, .next/static)';
+    console.time(collectLabel);
+    const nextStaticFiles = await (0, build_utils_1.glob)('**', path_1.default.join(entryPath, outputDirectory, 'static'));
+    const staticFolderFiles = await (0, build_utils_1.glob)('**', path_1.default.join(entryPath, 'static'));
+    let publicFolderFiles = {};
+    let publicFolderPath;
+    if (await fs_extra_1.default.pathExists(path_1.default.join(entryPath, 'public'))) {
+        publicFolderPath = path_1.default.join(entryPath, 'public');
+    }
+    else if (
+    // check at the same level as the output directory also
+    await fs_extra_1.default.pathExists(path_1.default.join(entryPath, outputDirectory, '../public'))) {
+        publicFolderPath = path_1.default.join(entryPath, outputDirectory, '../public');
+    }
+    if (publicFolderPath) {
+        (0, build_utils_1.debug)(`Using public folder at ${publicFolderPath}`);
+        publicFolderFiles = await (0, build_utils_1.glob)('**/*', publicFolderPath);
+    }
+    else {
+        (0, build_utils_1.debug)('No public folder found');
+    }
+    const staticFiles = {};
+    const staticDirectoryFiles = {};
+    const publicDirectoryFiles = {};
+    for (const file of Object.keys(nextStaticFiles)) {
+        staticFiles[path_1.default.join(entryDirectory, `_next/static/${file}`)] =
+            nextStaticFiles[file];
+    }
+    for (const file of Object.keys(staticFolderFiles)) {
+        staticDirectoryFiles[path_1.default.join(entryDirectory, 'static', file)] =
+            staticFolderFiles[file];
+    }
+    for (const file of Object.keys(publicFolderFiles)) {
+        publicDirectoryFiles[path_1.default.join(entryDirectory, file)] =
+            publicFolderFiles[file];
+    }
+    console.timeEnd(collectLabel);
+    return {
+        staticFiles,
+        staticDirectoryFiles,
+        publicDirectoryFiles,
+    };
+}
+exports.getStaticFiles = getStaticFiles;
+function normalizeIndexOutput(outputName, isServerMode) {
+    if (outputName !== '/index' && isServerMode) {
+        return outputName.replace(/\/index$/, '');
+    }
+    return outputName;
+}
+exports.normalizeIndexOutput = normalizeIndexOutput;
+/**
+ * The path to next-server was changed in
+ * https://github.com/vercel/next.js/pull/26756
+ */
+function getNextServerPath(nextVersion) {
+    return semver_1.default.gte(nextVersion, 'v11.0.2-canary.4')
+        ? 'next/dist/server'
+        : 'next/dist/next-server/server';
+}
+exports.getNextServerPath = getNextServerPath;
+// update to leverage
+function updateRouteSrc(route, index, manifestItems) {
+    if (route.src) {
+        route.src = manifestItems[index].regex;
+    }
+    return route;
+}
+exports.updateRouteSrc = updateRouteSrc;
+async function getPrivateOutputs(dir, entries) {
+    const files = {};
+    const routes = [];
+    for (const [existingFile, outputFile] of Object.entries(entries)) {
+        const fsPath = path_1.default.join(dir, existingFile);
+        try {
+            const { mode, size } = await (0, fs_extra_1.stat)(fsPath);
+            if (size > 30 * 1024 * 1024) {
+                throw new Error(`Exceeds maximum file size: ${size}`);
+            }
+            files[outputFile] = new build_utils_1.FileFsRef({ mode, fsPath });
+            routes.push({
+                src: `/${outputFile}`,
+                dest: '/404',
+                status: 404,
+                continue: true,
+            });
+        }
+        catch (error) {
+            (0, build_utils_1.debug)(`Private file ${existingFile} had an error and will not be uploaded: ${error}`);
+        }
+    }
+    return { files, routes };
+}
+exports.getPrivateOutputs = getPrivateOutputs;
+async function getMiddlewareBundle({ entryPath, outputDirectory, routesManifest, }) {
+    const middlewareManifest = await getMiddlewareManifest(entryPath, outputDirectory);
+    if (middlewareManifest && (middlewareManifest === null || middlewareManifest === void 0 ? void 0 : middlewareManifest.sortedMiddleware.length) > 0) {
+        const workerConfigs = await Promise.all(middlewareManifest.sortedMiddleware.map(async (key) => {
+            const middleware = middlewareManifest.middleware[key];
+            try {
+                const wrappedModuleSource = await (0, get_edge_function_source_1.getNextjsEdgeFunctionSource)(middleware.files, {
+                    name: middleware.name,
+                    staticRoutes: routesManifest.staticRoutes,
+                    dynamicRoutes: routesManifest.dynamicRoutes.filter(r => !('isMiddleware' in r)),
+                    nextConfig: {
+                        basePath: routesManifest.basePath,
+                        i18n: routesManifest.i18n,
+                    },
+                }, path_1.default.resolve(entryPath, outputDirectory), middleware.wasm);
+                return {
+                    page: middlewareManifest.middleware[key].page,
+                    edgeFunction: (() => {
+                        var _a;
+                        const { source, map } = wrappedModuleSource.sourceAndMap();
+                        const transformedMap = (0, sourcemapped_1.stringifySourceMap)(transformSourceMap(map));
+                        const wasmFiles = ((_a = middleware.wasm) !== null && _a !== void 0 ? _a : []).reduce((acc, { filePath, name }) => {
+                            const fullFilePath = path_1.default.join(entryPath, outputDirectory, filePath);
+                            acc[`wasm/${name}.wasm`] = new build_utils_1.FileFsRef({
+                                mode: 0o644,
+                                contentType: 'application/wasm',
+                                fsPath: fullFilePath,
+                            });
+                            return acc;
+                        }, {});
+                        return new build_utils_1.EdgeFunction({
+                            deploymentTarget: 'v8-worker',
+                            name: middleware.name,
+                            files: {
+                                'index.js': new build_utils_1.FileBlob({
+                                    data: source,
+                                    contentType: 'application/javascript',
+                                    mode: 0o644,
+                                }),
+                                ...(transformedMap && {
+                                    'index.js.map': new build_utils_1.FileBlob({
+                                        data: transformedMap,
+                                        contentType: 'application/json',
+                                        mode: 0o644,
+                                    }),
+                                }),
+                                ...wasmFiles,
+                            },
+                            entrypoint: 'index.js',
+                            envVarsInUse: middleware.env,
+                        });
+                    })(),
+                    routeSrc: getRouteSrc(middlewareManifest.middleware[key], routesManifest),
+                };
+            }
+            catch (e) {
+                e.message = `Can't build edge function ${key}: ${e.message}`;
+                throw e;
+            }
+        }));
+        const source = {
+            staticRoutes: [],
+            dynamicRouteMap: new Map(),
+            edgeFunctions: {},
+            middleware: [],
+        };
+        for (const worker of workerConfigs.values()) {
+            const edgeFile = worker.edgeFunction.name;
+            worker.edgeFunction.name = edgeFile.replace(/^pages\//, '');
+            source.edgeFunctions[edgeFile] = worker.edgeFunction;
+            const route = {
+                continue: true,
+                middlewarePath: edgeFile,
+                src: worker.routeSrc,
+            };
+            if (routesManifest.version > 3 && isDynamicRoute(worker.page)) {
+                source.dynamicRouteMap.set(worker.page, route);
+            }
+            else {
+                source.staticRoutes.push(route);
+            }
+        }
+        return source;
+    }
+    return {
+        staticRoutes: [],
+        dynamicRouteMap: new Map(),
+        edgeFunctions: {},
+        middleware: [],
+    };
+}
+exports.getMiddlewareBundle = getMiddlewareBundle;
+/**
+ * Attempts to read the middleware manifest from the pre-defined
+ * location. If the manifest can't be found it will resolve to
+ * undefined.
+ */
+async function getMiddlewareManifest(entryPath, outputDirectory) {
+    const middlewareManifestPath = path_1.default.join(entryPath, outputDirectory, './server/middleware-manifest.json');
+    const hasManifest = await fs_extra_1.default
+        .access(middlewareManifestPath)
+        .then(() => true)
+        .catch(() => false);
+    if (!hasManifest) {
+        return;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    return require(middlewareManifestPath);
+}
+/**
+ * For an object containing middleware info and a routes manifest this will
+ * generate a string with the route that will activate the middleware on
+ * Vercel Proxy.
+ *
+ * @param param0 The middleware info including regexp and page.
+ * @param param1 The routes manifest
+ * @returns A regexp string for the middleware route.
+ */
+function getRouteSrc({ regexp, page }, { basePath = '', i18n }) {
+    if (page === '/') {
+        return regexp.replace('_next', `${(basePath === null || basePath === void 0 ? void 0 : basePath.substring(1)) ? `${basePath === null || basePath === void 0 ? void 0 : basePath.substring(1)}/` : ''}_next`);
+    }
+    const locale = (i18n === null || i18n === void 0 ? void 0 : i18n.locales.length)
+        ? `(?:/(${i18n.locales
+            .map(locale => (0, escape_string_regexp_1.default)(locale))
+            .join('|')}))?`
+        : '';
+    return `(?:^${basePath}${locale}${regexp.substring(1)})`;
+}
+/**
+ * Makes the sources more human-readable in the source map
+ * by removing webpack-specific prefixes
+ */
+function transformSourceMap(sourcemap) {
+    var _a;
+    if (!sourcemap)
+        return;
+    const sources = (_a = sourcemap.sources) === null || _a === void 0 ? void 0 : _a.map(source => {
+        return source.replace(/^webpack:\/\/?_N_E\/(?:\.\/)?/, '');
+    }).map(source => {
+        return source.startsWith('?') ? '[native code]' : source;
+    });
+    return { ...sourcemap, sources };
+}