@vercel/build-utils 2.12.3-canary.7 → 2.13.1-canary.0

package/.turbo/turbo-build.log

@@ -0,0 +1,32 @@
+$ node build
+ncc: Version 0.24.0
+ncc: Compiling file index.js
+ncc: Using typescript@4.3.4 (local user-provided)
+   0kB  dist/main/should-serve.d.ts
+   0kB  dist/main/get-ignore-filter.d.ts
+   0kB  dist/main/detect-framework.d.ts
+   0kB  dist/main/fs/stream-to-buffer.d.ts
+   0kB  dist/main/fs/rename.d.ts
+   0kB  dist/main/fs/read-config-file.d.ts
+   0kB  dist/main/fs/normalize-path.d.ts
+   0kB  dist/main/fs/node-version.d.ts
+   0kB  dist/main/fs/glob.d.ts
+   0kB  dist/main/fs/get-writable-directory.d.ts
+   0kB  dist/main/fs/download.d.ts
+   0kB  dist/main/debug.d.ts
+   1kB  dist/main/schemas.d.ts
+   1kB  dist/main/prerender.d.ts
+   1kB  dist/main/lambda.d.ts
+   1kB  dist/main/file-ref.d.ts
+   1kB  dist/main/file-fs-ref.d.ts
+   1kB  dist/main/file-blob.d.ts
+   1kB  dist/main/errors.d.ts
+   1kB  dist/main/detect-file-system-api.d.ts
+   1kB  dist/main/detect-builders.d.ts
+   2kB  dist/main/detectors/filesystem.d.ts
+   2kB  dist/main/convert-runtime-to-plugin.d.ts
+   3kB  dist/main/index.d.ts
+   3kB  dist/main/fs/run-user-scripts.d.ts
+   9kB  dist/main/types.d.ts
+1244kB  dist/main/index.js
+1272kB  [8092ms] - ncc 0.24.0

package/dist/convert-runtime-to-plugin.d.ts

@@ -0,0 +1,65 @@
+import { Lambda } from './lambda';
+import type { BuildOptions } from './types';
+/**
+ * Convert legacy Runtime to a Plugin.
+ * @param buildRuntime - a legacy build() function from a Runtime
+ * @param packageName - the name of the package, for example `vercel-plugin-python`
+ * @param ext - the file extension, for example `.py`
+ */
+export declare function _experimental_convertRuntimeToPlugin(buildRuntime: (options: BuildOptions) => Promise<{
+    output: Lambda;
+}>, packageName: string, ext: string): ({ workPath }: {
+    workPath: string;
+}) => Promise<void>;
+/**
+ * If `.output/functions-manifest.json` exists, append to the pages
+ * property. Otherwise write a new file.
+ */
+export declare function _experimental_updateFunctionsManifest({ workPath, pages, }: {
+    workPath: string;
+    pages: {
+        [key: string]: any;
+    };
+}): Promise<void>;
+/**
+ * Append routes to the `routes-manifest.json` file.
+ * If the file does not exist, it will be created.
+ */
+export declare function _experimental_updateRoutesManifest({ workPath, redirects, rewrites, headers, dynamicRoutes, staticRoutes, }: {
+    workPath: string;
+    redirects?: {
+        source: string;
+        destination: string;
+        statusCode: number;
+        regex: string;
+    }[];
+    rewrites?: {
+        source: string;
+        destination: string;
+        regex: string;
+    }[];
+    headers?: {
+        source: string;
+        headers: {
+            key: string;
+            value: string;
+        }[];
+        regex: string;
+    }[];
+    dynamicRoutes?: {
+        page: string;
+        regex: string;
+        namedRegex?: string;
+        routeKeys?: {
+            [named: string]: string;
+        };
+    }[];
+    staticRoutes?: {
+        page: string;
+        regex: string;
+        namedRegex?: string;
+        routeKeys?: {
+            [named: string]: string;
+        };
+    }[];
+}): Promise<void>;

package/dist/convert-runtime-to-plugin.js

@@ -0,0 +1,298 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._experimental_updateRoutesManifest = exports._experimental_updateFunctionsManifest = exports._experimental_convertRuntimeToPlugin = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = require("path");
+const glob_1 = __importDefault(require("./fs/glob"));
+const normalize_path_1 = require("./fs/normalize-path");
+const lambda_1 = require("./lambda");
+const _1 = require(".");
+// `.output` was already created by the Build Command, so we have
+// to ensure its contents don't get bundled into the Lambda. Similarily,
+// we don't want to bundle anything from `.vercel` either. Lastly,
+// Builders/Runtimes didn't have `vercel.json` or `now.json`.
+const ignoredPaths = ['.output', '.vercel', 'vercel.json', 'now.json'];
+const shouldIgnorePath = (file, ignoreFilter, ignoreFile) => {
+    const isNative = ignoredPaths.some(item => {
+        return file.startsWith(item);
+    });
+    if (!ignoreFile) {
+        return isNative;
+    }
+    return isNative || ignoreFilter(file);
+};
+const getSourceFiles = async (workPath, ignoreFilter) => {
+    const list = await glob_1.default('**', {
+        cwd: workPath,
+    });
+    // We're not passing this as an `ignore` filter to the `glob` function above,
+    // so that we can re-use exactly the same `getIgnoreFilter` method that the
+    // Build Step uses (literally the same code). Note that this exclusion only applies
+    // when deploying. Locally, another exclusion is needed, which is handled
+    // further below in the `convertRuntimeToPlugin` function.
+    for (const file in list) {
+        if (shouldIgnorePath(file, ignoreFilter, true)) {
+            delete list[file];
+        }
+    }
+    return list;
+};
+/**
+ * Convert legacy Runtime to a Plugin.
+ * @param buildRuntime - a legacy build() function from a Runtime
+ * @param packageName - the name of the package, for example `vercel-plugin-python`
+ * @param ext - the file extension, for example `.py`
+ */
+function _experimental_convertRuntimeToPlugin(buildRuntime, packageName, ext) {
+    // This `build()` signature should match `plugin.build()` signature in `vercel build`.
+    return async function build({ workPath }) {
+        // We also don't want to provide any files to Runtimes that were ignored
+        // through `.vercelignore` or `.nowignore`, because the Build Step does the same.
+        const ignoreFilter = await _1.getIgnoreFilter(workPath);
+        // Retrieve the files that are currently available on the File System,
+        // before the Legacy Runtime has even started to build.
+        const sourceFilesPreBuild = await getSourceFiles(workPath, ignoreFilter);
+        // Instead of doing another `glob` to get all the matching source files,
+        // we'll filter the list of existing files down to only the ones
+        // that are matching the entrypoint pattern, so we're first creating
+        // a clean new list to begin.
+        const entrypoints = Object.assign({}, sourceFilesPreBuild);
+        const entrypointMatch = new RegExp(`^api/.*${ext}$`);
+        // Up next, we'll strip out the files from the list of entrypoints
+        // that aren't actually considered entrypoints.
+        for (const file in entrypoints) {
+            if (!entrypointMatch.test(file)) {
+                delete entrypoints[file];
+            }
+        }
+        const pages = {};
+        const pluginName = packageName.replace('vercel-plugin-', '');
+        const outputPath = path_1.join(workPath, '.output');
+        const traceDir = path_1.join(outputPath, `inputs`, 
+        // Legacy Runtimes can only provide API Routes, so that's
+        // why we can use this prefix for all of them. Here, we have to
+        // make sure to not use a cryptic hash name, because people
+        // need to be able to easily inspect the output.
+        `api-routes-${pluginName}`);
+        await fs_extra_1.default.ensureDir(traceDir);
+        const entryRoot = path_1.join(outputPath, 'server', 'pages');
+        for (const entrypoint of Object.keys(entrypoints)) {
+            const { output } = await buildRuntime({
+                files: sourceFilesPreBuild,
+                entrypoint,
+                workPath,
+                config: {
+                    zeroConfig: true,
+                },
+                meta: {
+                    avoidTopLevelInstall: true,
+                    skipDownload: true,
+                },
+            });
+            // @ts-ignore This symbol is a private API
+            const lambdaFiles = output[lambda_1.FILES_SYMBOL];
+            // When deploying, the `files` that are passed to the Legacy Runtimes already
+            // have certain files that are ignored stripped, but locally, that list of
+            // files isn't used by the Legacy Runtimes, so we need to apply the filters
+            // to the outputs that they are returning instead.
+            for (const file in lambdaFiles) {
+                if (shouldIgnorePath(file, ignoreFilter, false)) {
+                    delete lambdaFiles[file];
+                }
+            }
+            let handlerFileBase = output.handler;
+            let handlerFile = lambdaFiles[handlerFileBase];
+            let handlerHasImport = false;
+            const { handler } = output;
+            const handlerMethod = handler.split('.').pop();
+            const handlerFileName = handler.replace(`.${handlerMethod}`, '');
+            // For compiled languages, the launcher file for the Lambda generated
+            // by the Legacy Runtime matches the `handler` defined for it, but for
+            // interpreted languages, the `handler` consists of the launcher file name
+            // without an extension, plus the name of the method inside of that file
+            // that should be invoked, so we have to construct the file path explicitly.
+            if (!handlerFile) {
+                handlerFileBase = handlerFileName + ext;
+                handlerFile = lambdaFiles[handlerFileBase];
+                handlerHasImport = true;
+            }
+            if (!handlerFile || !handlerFile.fsPath) {
+                throw new Error(`Could not find a handler file. Please ensure that \`files\` for the returned \`Lambda\` contains an \`FileFsRef\` named "${handlerFileBase}" with a valid \`fsPath\`.`);
+            }
+            const handlerExtName = path_1.extname(handlerFile.fsPath);
+            const entryBase = path_1.basename(entrypoint).replace(ext, handlerExtName);
+            const entryPath = path_1.join(path_1.dirname(entrypoint), entryBase);
+            const entry = path_1.join(entryRoot, entryPath);
+            // Create the parent directory of the API Route that will be created
+            // for the current entrypoint inside of `.output/server/pages/api`.
+            await fs_extra_1.default.ensureDir(path_1.dirname(entry));
+            // For compiled languages, the launcher file will be binary and therefore
+            // won't try to import a user-provided request handler (instead, it will
+            // contain it). But for interpreted languages, the launcher might try to
+            // load a user-provided request handler from the source file instead of bundling
+            // it, so we have to adjust the import statement inside the launcher to point
+            // to the respective source file. Previously, Legacy Runtimes simply expected
+            // the user-provided request-handler to be copied right next to the launcher,
+            // but with the new File System API, files won't be moved around unnecessarily.
+            if (handlerHasImport) {
+                const { fsPath } = handlerFile;
+                const encoding = 'utf-8';
+                // This is the true directory of the user-provided request handler in the
+                // source files, so that's what we will use as an import path in the launcher.
+                const locationPrefix = path_1.relative(entry, outputPath);
+                let handlerContent = await fs_extra_1.default.readFile(fsPath, encoding);
+                const importPaths = [
+                    // This is the full entrypoint path, like `./api/test.py`. In our tests
+                    // Python didn't support importing from a parent directory without using different
+                    // code in the launcher that registers it as a location for modules and then changing
+                    // the importing syntax, but continuing to import it like before seems to work. If
+                    // other languages need this, we should consider excluding Python explicitly.
+                    // `./${entrypoint}`,
+                    // This is the entrypoint path without extension, like `api/test`
+                    entrypoint.slice(0, -ext.length),
+                ];
+                // Generate a list of regular expressions that we can use for
+                // finding matches, but only allow matches if the import path is
+                // wrapped inside single (') or double quotes (").
+                const patterns = importPaths.map(path => {
+                    // eslint-disable-next-line no-useless-escape
+                    return new RegExp(`('|")(${path.replace(/\./g, '\\.')})('|")`, 'g');
+                });
+                let replacedMatch = null;
+                for (const pattern of patterns) {
+                    const newContent = handlerContent.replace(pattern, (_, p1, p2, p3) => {
+                        return `${p1}${path_1.join(locationPrefix, p2)}${p3}`;
+                    });
+                    if (newContent !== handlerContent) {
+                        _1.debug(`Replaced "${pattern}" inside "${entry}" to ensure correct import of user-provided request handler`);
+                        handlerContent = newContent;
+                        replacedMatch = true;
+                    }
+                }
+                if (!replacedMatch) {
+                    new Error(`No replacable matches for "${importPaths[0]}" or "${importPaths[1]}" found in "${fsPath}"`);
+                }
+                await fs_extra_1.default.writeFile(entry, handlerContent, encoding);
+            }
+            else {
+                await fs_extra_1.default.copy(handlerFile.fsPath, entry);
+            }
+            // Legacy Runtimes based on interpreted languages will create a new launcher file
+            // for every entrypoint, but they will create each one inside `workPath`, which means that
+            // the launcher for one entrypoint will overwrite the launcher provided for the previous
+            // entrypoint. That's why, above, we copy the file contents into the new destination (and
+            // optionally transform them along the way), instead of linking. We then also want to remove
+            // the copy origin right here, so that the `workPath` doesn't contain a useless launcher file
+            // once the build has finished running.
+            await fs_extra_1.default.remove(handlerFile.fsPath);
+            _1.debug(`Removed temporary file "${handlerFile.fsPath}"`);
+            const nft = `${entry}.nft.json`;
+            const json = JSON.stringify({
+                version: 2,
+                files: Object.keys(lambdaFiles)
+                    .map(file => {
+                    const { fsPath } = lambdaFiles[file];
+                    if (!fsPath) {
+                        throw new Error(`File "${file}" is missing valid \`fsPath\` property`);
+                    }
+                    // The handler was already moved into position above.
+                    if (file === handlerFileBase) {
+                        return;
+                    }
+                    return normalize_path_1.normalizePath(path_1.relative(path_1.dirname(nft), fsPath));
+                })
+                    .filter(Boolean),
+            });
+            await fs_extra_1.default.writeFile(nft, json);
+            // Add an entry that will later on be added to the `functions-manifest.json`
+            // file that is placed inside of the `.output` directory.
+            pages[normalize_path_1.normalizePath(entryPath)] = {
+                // Because the underlying file used as a handler was placed
+                // inside `.output/server/pages/api`, it no longer has the name it originally
+                // had and is now named after the API Route that it's responsible for,
+                // so we have to adjust the name of the Lambda handler accordingly.
+                handler: handler.replace(handlerFileName, path_1.parse(entry).name),
+                runtime: output.runtime,
+                memory: output.memory,
+                maxDuration: output.maxDuration,
+                environment: output.environment,
+                allowQuery: output.allowQuery,
+            };
+        }
+        // Add any Serverless Functions that were exposed by the Legacy Runtime
+        // to the `functions-manifest.json` file provided in `.output`.
+        await _experimental_updateFunctionsManifest({ workPath, pages });
+    };
+}
+exports._experimental_convertRuntimeToPlugin = _experimental_convertRuntimeToPlugin;
+async function readJson(filePath) {
+    try {
+        const str = await fs_extra_1.default.readFile(filePath, 'utf8');
+        return JSON.parse(str);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return {};
+        }
+        throw err;
+    }
+}
+/**
+ * If `.output/functions-manifest.json` exists, append to the pages
+ * property. Otherwise write a new file.
+ */
+async function _experimental_updateFunctionsManifest({ workPath, pages, }) {
+    const functionsManifestPath = path_1.join(workPath, '.output', 'functions-manifest.json');
+    const functionsManifest = await readJson(functionsManifestPath);
+    if (!functionsManifest.version)
+        functionsManifest.version = 2;
+    if (!functionsManifest.pages)
+        functionsManifest.pages = {};
+    for (const [pageKey, pageConfig] of Object.entries(pages)) {
+        functionsManifest.pages[pageKey] = { ...pageConfig };
+    }
+    await fs_extra_1.default.writeFile(functionsManifestPath, JSON.stringify(functionsManifest));
+}
+exports._experimental_updateFunctionsManifest = _experimental_updateFunctionsManifest;
+/**
+ * Append routes to the `routes-manifest.json` file.
+ * If the file does not exist, it will be created.
+ */
+async function _experimental_updateRoutesManifest({ workPath, redirects, rewrites, headers, dynamicRoutes, staticRoutes, }) {
+    const routesManifestPath = path_1.join(workPath, '.output', 'routes-manifest.json');
+    const routesManifest = await readJson(routesManifestPath);
+    if (!routesManifest.version)
+        routesManifest.version = 3;
+    if (routesManifest.pages404 === undefined)
+        routesManifest.pages404 = true;
+    if (redirects) {
+        if (!routesManifest.redirects)
+            routesManifest.redirects = [];
+        routesManifest.redirects.push(...redirects);
+    }
+    if (rewrites) {
+        if (!routesManifest.rewrites)
+            routesManifest.rewrites = [];
+        routesManifest.rewrites.push(...rewrites);
+    }
+    if (headers) {
+        if (!routesManifest.headers)
+            routesManifest.headers = [];
+        routesManifest.headers.push(...headers);
+    }
+    if (dynamicRoutes) {
+        if (!routesManifest.dynamicRoutes)
+            routesManifest.dynamicRoutes = [];
+        routesManifest.dynamicRoutes.push(...dynamicRoutes);
+    }
+    if (staticRoutes) {
+        if (!routesManifest.staticRoutes)
+            routesManifest.staticRoutes = [];
+        routesManifest.staticRoutes.push(...staticRoutes);
+    }
+    await fs_extra_1.default.writeFile(routesManifestPath, JSON.stringify(routesManifest));
+}
+exports._experimental_updateRoutesManifest = _experimental_updateRoutesManifest;

package/dist/detect-builders.d.ts

@@ -1,5 +1,5 @@
 import { Route } from '@vercel/routing-utils';
-import { PackageJson, Builder, BuilderFunctions } from './types';
+import { PackageJson, Builder, BuilderFunctions, ProjectSettings } from './types';
 interface ErrorResponse {
     code: string;
     message: string;
@@ -10,14 +10,7 @@ interface Options {
     tag?: 'canary' | 'latest' | string;
     functions?: BuilderFunctions;
     ignoreBuildScript?: boolean;
-    projectSettings?: {
-        framework?: string | null;
-        devCommand?: string | null;
-        installCommand?: string | null;
-        buildCommand?: string | null;
-        outputDirectory?: string | null;
-        createdAt?: number;
-    };
+    projectSettings?: ProjectSettings;
     cleanUrls?: boolean;
     trailingSlash?: boolean;
     featHandleMiss?: boolean;
@@ -34,5 +27,11 @@ export declare function detectBuilders(files: string[], pkg?: PackageJson | unde
     redirectRoutes: Route[] | null;
     rewriteRoutes: Route[] | null;
     errorRoutes: Route[] | null;
+    limitedRoutes: LimitedRoutes | null;
 }>;
+interface LimitedRoutes {
+    defaultRoutes: Route[];
+    redirectRoutes: Route[];
+    rewriteRoutes: Route[];
+}
 export {};

package/dist/detect-builders.js

@@ -66,6 +66,7 @@ async function detectBuilders(files, pkg, options = {}) {
             redirectRoutes: null,
             rewriteRoutes: null,
             errorRoutes: null,
+            limitedRoutes: null,
         };
     }
     const sortedFiles = files.sort(sortFiles);
@@ -113,6 +114,7 @@ async function detectBuilders(files, pkg, options = {}) {
                     redirectRoutes: null,
                     rewriteRoutes: null,
                     errorRoutes: null,
+                    limitedRoutes: null,
                 };
             }
             if (apiRoute) {
@@ -167,6 +169,7 @@ async function detectBuilders(files, pkg, options = {}) {
                 defaultRoutes: null,
                 rewriteRoutes: null,
                 errorRoutes: null,
+                limitedRoutes: null,
             };
         }
         // If `outputDirectory` is an empty string,
@@ -203,6 +206,7 @@ async function detectBuilders(files, pkg, options = {}) {
             defaultRoutes: null,
             rewriteRoutes: null,
             errorRoutes: null,
+            limitedRoutes: null,
         };
     }
     const builders = [];
@@ -221,7 +225,7 @@ async function detectBuilders(files, pkg, options = {}) {
             });
         }
     }
-    const routesResult = getRouteResult(apiRoutes, dynamicRoutes, usedOutputDirectory, apiBuilders, frontendBuilder, options);
+    const routesResult = getRouteResult(pkg, apiRoutes, dynamicRoutes, usedOutputDirectory, apiBuilders, frontendBuilder, options);
     return {
         warnings,
         builders: builders.length ? builders : null,
@@ -230,6 +234,7 @@ async function detectBuilders(files, pkg, options = {}) {
         defaultRoutes: routesResult.defaultRoutes,
         rewriteRoutes: routesResult.rewriteRoutes,
         errorRoutes: routesResult.errorRoutes,
+        limitedRoutes: routesResult.limitedRoutes,
     };
 }
 exports.detectBuilders = detectBuilders;
@@ -670,23 +675,51 @@ function createRouteFromPath(filePath, featHandleMiss, cleanUrls) {
     }
     return { route, isDynamic };
 }
-function getRouteResult(apiRoutes, dynamicRoutes, outputDirectory, apiBuilders, frontendBuilder, options) {
+function getRouteResult(pkg, apiRoutes, dynamicRoutes, outputDirectory, apiBuilders, frontendBuilder, options) {
     var _a, _b;
+    const deps = Object.assign({}, pkg === null || pkg === void 0 ? void 0 : pkg.dependencies, pkg === null || pkg === void 0 ? void 0 : pkg.devDependencies);
     const defaultRoutes = [];
     const redirectRoutes = [];
     const rewriteRoutes = [];
     const errorRoutes = [];
+    const limitedRoutes = {
+        defaultRoutes: [],
+        redirectRoutes: [],
+        rewriteRoutes: [],
+    };
     const framework = ((_a = frontendBuilder === null || frontendBuilder === void 0 ? void 0 : frontendBuilder.config) === null || _a === void 0 ? void 0 : _a.framework) || '';
     const isNextjs = framework === 'nextjs' || _1.isOfficialRuntime('next', frontendBuilder === null || frontendBuilder === void 0 ? void 0 : frontendBuilder.use);
     const ignoreRuntimes = (_b = slugToFramework.get(framework)) === null || _b === void 0 ? void 0 : _b.ignoreRuntimes;
     if (apiRoutes && apiRoutes.length > 0) {
         if (options.featHandleMiss) {
+            // Exclude extension names if the corresponding plugin is not found in package.json
+            // detectBuilders({ignoreRoutesForBuilders: ['@vercel/python']})
+            // return a copy of routes.
+            // We should exclud errorRoutes and
             const extSet = detectApiExtensions(apiBuilders);
+            const withTag = options.tag ? `@${options.tag}` : '';
+            const extSetLimited = detectApiExtensions(apiBuilders.filter(b => {
+                if (b.use === `@vercel/python${withTag}` &&
+                    !('vercel-plugin-python' in deps)) {
+                    return false;
+                }
+                if (b.use === `@vercel/go${withTag}` &&
+                    !('vercel-plugin-go' in deps)) {
+                    return false;
+                }
+                if (b.use === `@vercel/ruby${withTag}` &&
+                    !('vercel-plugin-ruby' in deps)) {
+                    return false;
+                }
+                return true;
+            }));
             if (extSet.size > 0) {
-                const exts = Array.from(extSet)
+                const extGroup = `(?:\\.(?:${Array.from(extSet)
                     .map(ext => ext.slice(1))
-                    .join('|');
-                const extGroup = `(?:\\.(?:${exts}))`;
+                    .join('|')}))`;
+                const extGroupLimited = `(?:\\.(?:${Array.from(extSetLimited)
+                    .map(ext => ext.slice(1))
+                    .join('|')}))`;
                 if (options.cleanUrls) {
                     redirectRoutes.push({
                         src: `^/(api(?:.+)?)/index${extGroup}?/?$`,
@@ -700,6 +733,18 @@ function getRouteResult(apiRoutes, dynamicRoutes, outputDirectory, apiBuilders,
                         },
                         status: 308,
                     });
+                    limitedRoutes.redirectRoutes.push({
+                        src: `^/(api(?:.+)?)/index${extGroupLimited}?/?$`,
+                        headers: { Location: options.trailingSlash ? '/$1/' : '/$1' },
+                        status: 308,
+                    });
+                    limitedRoutes.redirectRoutes.push({
+                        src: `^/api/(.+)${extGroupLimited}/?$`,
+                        headers: {
+                            Location: options.trailingSlash ? '/api/$1/' : '/api/$1',
+                        },
+                        status: 308,
+                    });
                 }
                 else {
                     defaultRoutes.push({ handle: 'miss' });
@@ -708,9 +753,16 @@ function getRouteResult(apiRoutes, dynamicRoutes, outputDirectory, apiBuilders,
                         dest: '/api/$1',
                         check: true,
                     });
+                    limitedRoutes.defaultRoutes.push({ handle: 'miss' });
+                    limitedRoutes.defaultRoutes.push({
+                        src: `^/api/(.+)${extGroupLimited}$`,
+                        dest: '/api/$1',
+                        check: true,
+                    });
                 }
             }
             rewriteRoutes.push(...dynamicRoutes);
+            limitedRoutes.rewriteRoutes.push(...dynamicRoutes);
             if (typeof ignoreRuntimes === 'undefined') {
                 // This route is only necessary to hide the directory listing
                 // to avoid enumerating serverless function names.
@@ -755,6 +807,7 @@ function getRouteResult(apiRoutes, dynamicRoutes, outputDirectory, apiBuilders,
         redirectRoutes,
         rewriteRoutes,
         errorRoutes,
+        limitedRoutes,
     };
 }
 function sortFilesBySegmentCount(fileA, fileB) {

package/dist/detect-file-system-api.d.ts

@@ -0,0 +1,34 @@
+import type { Builder, BuilderFunctions, PackageJson, ProjectSettings } from './types';
+interface Metadata {
+    plugins: string[];
+    hasDotOutput: boolean;
+    hasMiddleware: boolean;
+}
+/**
+ * If the Deployment can be built with the new File System API,
+ * return the new Builder. Otherwise an "Exclusion Condition"
+ * was hit so return `null` builder with a `reason` for exclusion.
+ */
+export declare function detectFileSystemAPI({ files, projectSettings, builders, vercelConfig, pkg, tag, enableFlag, }: {
+    files: {
+        [relPath: string]: any;
+    };
+    projectSettings: ProjectSettings;
+    builders: Builder[];
+    vercelConfig: {
+        builds?: Builder[];
+        functions?: BuilderFunctions;
+    } | null | undefined;
+    pkg: PackageJson | null | undefined;
+    tag: string | undefined;
+    enableFlag: boolean | undefined;
+}): Promise<{
+    metadata: Metadata;
+    fsApiBuilder: Builder;
+    reason: null;
+} | {
+    metadata: Metadata;
+    fsApiBuilder: null;
+    reason: string;
+}>;
+export {};