@vercel/build-utils 2.12.3-canary.30 → 2.12.3-canary.34

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

@@ -24,6 +24,22 @@ const shouldIgnorePath = (file, ignoreFilter, ignoreFile) => {
     }
     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
@@ -33,22 +49,25 @@ const shouldIgnorePath = (file, ignoreFilter, ignoreFile) => {
 function convertRuntimeToPlugin(buildRuntime, packageName, ext) {
     // This `build()` signature should match `plugin.build()` signature in `vercel build`.
     return async function build({ workPath }) {
-        const opts = { cwd: workPath };
-        const files = await glob_1.default('**', opts);
         // 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);
-        // 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 further below is needed.
-        for (const file in files) {
-            if (shouldIgnorePath(file, ignoreFilter, true)) {
-                delete files[file];
+        // 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 entrypointPattern = `api/**/*${ext}`;
-        const entrypoints = await glob_1.default(entrypointPattern, opts);
         const pages = {};
         const pluginName = packageName.replace('vercel-plugin-', '');
         const traceDir = path_1.join(workPath, `.output`, `inputs`, 
@@ -58,9 +77,11 @@ function convertRuntimeToPlugin(buildRuntime, packageName, ext) {
         // need to be able to easily inspect the output.
         `api-routes-${pluginName}`);
         await fs_extra_1.default.ensureDir(traceDir);
+        let newPathsRuntime = new Set();
+        let linkersRuntime = [];
         for (const entrypoint of Object.keys(entrypoints)) {
             const { output } = await buildRuntime({
-                files,
+                files: sourceFilesPreBuild,
                 entrypoint,
                 workPath,
                 config: {
@@ -70,14 +91,21 @@ function convertRuntimeToPlugin(buildRuntime, packageName, ext) {
                     avoidTopLevelInstall: true,
                 },
             });
-            pages[entrypoint] = {
-                handler: output.handler,
-                runtime: output.runtime,
-                memory: output.memory,
-                maxDuration: output.maxDuration,
-                environment: output.environment,
-                allowQuery: output.allowQuery,
-            };
+            // Legacy Runtimes tend to pollute the `workPath` with compiled results,
+            // because the `workPath` used to be a place that was a place where they could
+            // just put anything, but nowadays it's the working directory of the `vercel build`
+            // command, which is the place where the developer keeps their source files,
+            // so we don't want to pollute this space unnecessarily. That means we have to clean
+            // up files that were created by the build, which is done further below.
+            const sourceFilesAfterBuild = await getSourceFiles(workPath, ignoreFilter);
+            // Further down, we will need the filename of the Lambda handler
+            // for placing it inside `server/pages/api`, but because Legacy Runtimes
+            // don't expose the filename directly, we have to construct it
+            // from the handler name, and then find the matching file further below,
+            // because we don't yet know its extension here.
+            const handler = output.handler;
+            const handlerMethod = handler.split('.').reverse()[0];
+            const handlerFileName = handler.replace(`.${handlerMethod}`, '');
             // @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
@@ -89,35 +117,156 @@ function convertRuntimeToPlugin(buildRuntime, packageName, ext) {
                     delete lambdaFiles[file];
                 }
             }
+            const handlerFilePath = Object.keys(lambdaFiles).find(item => {
+                return path_1.parse(item).name === handlerFileName;
+            });
+            const handlerFileOrigin = lambdaFiles[handlerFilePath || ''].fsPath;
+            if (!handlerFileOrigin) {
+                throw new Error(`Could not find a handler file. Please ensure that the list of \`files\` defined for the returned \`Lambda\` contains a file with the name ${handlerFileName} (+ any extension).`);
+            }
             const entry = path_1.join(workPath, '.output', 'server', 'pages', entrypoint);
+            // We never want to link here, only copy, because the launcher
+            // file often has the same name for every entrypoint, which means that
+            // every build for every entrypoint overwrites the launcher of the previous
+            // one, so linking would end with a broken reference.
             await fs_extra_1.default.ensureDir(path_1.dirname(entry));
-            await linkOrCopy(files[entrypoint].fsPath, entry);
+            await fs_extra_1.default.copy(handlerFileOrigin, entry);
+            const newFilesEntrypoint = [];
+            const newDirectoriesEntrypoint = [];
+            const preBuildFiles = Object.values(sourceFilesPreBuild).map(file => {
+                return file.fsPath;
+            });
+            // Generate a list of directories and files that weren't present
+            // before the entrypoint was processed by the Legacy Runtime, so
+            // that we can perform a cleanup later. We need to divide into files
+            // and directories because only cleaning up files might leave empty
+            // directories, and listing directories separately also speeds up the
+            // build because we can just delete them, which wipes all of their nested
+            // paths, instead of iterating through all files that should be deleted.
+            for (const file in sourceFilesAfterBuild) {
+                if (!sourceFilesPreBuild[file]) {
+                    const path = sourceFilesAfterBuild[file].fsPath;
+                    const dirPath = path_1.dirname(path);
+                    // If none of the files that were present before the entrypoint
+                    // was processed are contained within the directory we're looking
+                    // at right now, then we know it's a newly added directory
+                    // and it can therefore be removed later on.
+                    const isNewDir = !preBuildFiles.some(filePath => {
+                        return path_1.dirname(filePath).startsWith(dirPath);
+                    });
+                    // Check out the list of tracked directories that were
+                    // newly added and see if one of them contains the path
+                    // we're looking at.
+                    const hasParentDir = newDirectoriesEntrypoint.some(dir => {
+                        return path.startsWith(dir);
+                    });
+                    // If we have already tracked a directory that was newly
+                    // added that sits above the file or directory that we're
+                    // looking at, we don't need to add more entries to the list
+                    // because when the parent will get removed in the future,
+                    // all of its children (and therefore the path we're looking at)
+                    // will automatically get removed anyways.
+                    if (hasParentDir) {
+                        continue;
+                    }
+                    if (isNewDir) {
+                        newDirectoriesEntrypoint.push(dirPath);
+                    }
+                    else {
+                        newFilesEntrypoint.push(path);
+                    }
+                }
+            }
             const tracedFiles = [];
-            Object.entries(lambdaFiles).forEach(async ([relPath, file]) => {
+            const linkers = Object.entries(lambdaFiles).map(async ([relPath, file]) => {
                 const newPath = path_1.join(traceDir, relPath);
+                // The handler was already moved into position above.
+                if (relPath === handlerFilePath) {
+                    return;
+                }
                 tracedFiles.push({ absolutePath: newPath, relativePath: relPath });
-                if (file.fsPath) {
-                    await linkOrCopy(file.fsPath, newPath);
+                const { fsPath, type } = file;
+                if (fsPath) {
+                    await fs_extra_1.default.ensureDir(path_1.dirname(newPath));
+                    const isNewFile = newFilesEntrypoint.includes(fsPath);
+                    const isInsideNewDirectory = newDirectoriesEntrypoint.some(dirPath => {
+                        return fsPath.startsWith(dirPath);
+                    });
+                    // With this, we're making sure that files in the `workPath` that existed
+                    // before the Legacy Runtime was invoked (source files) are linked from
+                    // `.output` instead of copying there (the latter only happens if linking fails),
+                    // which is the fastest solution. However, files that are created fresh
+                    // by the Legacy Runtimes are always copied, because their link destinations
+                    // are likely to be overwritten every time an entrypoint is processed by
+                    // the Legacy Runtime. This is likely to overwrite the destination on subsequent
+                    // runs, but that's also how `workPath` used to work originally, without
+                    // the File System API (meaning that there was one `workPath` for all entrypoints).
+                    if (isNewFile || isInsideNewDirectory) {
+                        _1.debug(`Copying from ${fsPath} to ${newPath}`);
+                        await fs_extra_1.default.copy(fsPath, newPath);
+                    }
+                    else {
+                        await linkOrCopy(fsPath, newPath);
+                    }
                 }
-                else if (file.type === 'FileBlob') {
+                else if (type === 'FileBlob') {
                     const { data, mode } = file;
                     await fs_extra_1.default.writeFile(newPath, data, { mode });
                 }
                 else {
-                    throw new Error(`Unknown file type: ${file.type}`);
+                    throw new Error(`Unknown file type: ${type}`);
                 }
             });
+            linkersRuntime = linkersRuntime.concat(linkers);
             const nft = path_1.join(workPath, '.output', 'server', 'pages', `${entrypoint}.nft.json`);
             const json = JSON.stringify({
                 version: 1,
-                files: tracedFiles.map(f => ({
-                    input: normalize_path_1.normalizePath(path_1.relative(nft, f.absolutePath)),
-                    output: normalize_path_1.normalizePath(f.relativePath),
+                files: tracedFiles.map(file => ({
+                    input: normalize_path_1.normalizePath(path_1.relative(path_1.dirname(nft), file.absolutePath)),
+                    output: normalize_path_1.normalizePath(file.relativePath),
                 })),
             });
             await fs_extra_1.default.ensureDir(path_1.dirname(nft));
             await fs_extra_1.default.writeFile(nft, json);
+            // Extend the list of directories and files that were created by the
+            // Legacy Runtime with the list of directories and files that were
+            // created for the entrypoint that was just processed above.
+            newPathsRuntime = new Set([
+                ...newPathsRuntime,
+                ...newFilesEntrypoint,
+                ...newDirectoriesEntrypoint,
+            ]);
+            const apiRouteHandler = `${path_1.parse(entry).name}.${handlerMethod}`;
+            // Add an entry that will later on be added to the `functions-manifest.json`
+            // file that is placed inside of the `.output` directory.
+            pages[entrypoint] = {
+                handler: apiRouteHandler,
+                runtime: output.runtime,
+                memory: output.memory,
+                maxDuration: output.maxDuration,
+                environment: output.environment,
+                allowQuery: output.allowQuery,
+            };
         }
+        // Instead of of waiting for all of the linking to be done for every
+        // entrypoint before processing the next one, we immediately handle all
+        // of them one after the other, while then waiting for the linking
+        // to finish right here, before we clean up newly created files below.
+        await Promise.all(linkersRuntime);
+        // A list of all the files that were created by the Legacy Runtime,
+        // which we'd like to remove from the File System.
+        const toRemove = Array.from(newPathsRuntime).map(path => {
+            _1.debug(`Removing ${path} as part of cleanup`);
+            return fs_extra_1.default.remove(path);
+        });
+        // Once all the entrypoints have been processed, we'd like to
+        // remove all the files from `workPath` that originally weren't present
+        // before the Legacy Runtime began running, because the `workPath`
+        // is nowadays the directory in which the user keeps their source code, since
+        // we're no longer running separate parallel builds for every Legacy Runtime.
+        await Promise.all(toRemove);
+        // Add any Serverless Functions that were exposed by the Legacy Runtime
+        // to the `functions-manifest.json` file provided in `.output`.
         await updateFunctionsManifest({ workPath, pages });
     };
 }

package/dist/index.js

@@ -32771,6 +32771,22 @@ const shouldIgnorePath = (file, ignoreFilter, ignoreFile) => {
     }
     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
@@ -32780,22 +32796,25 @@ const shouldIgnorePath = (file, ignoreFilter, ignoreFile) => {
 function convertRuntimeToPlugin(buildRuntime, packageName, ext) {
     // This `build()` signature should match `plugin.build()` signature in `vercel build`.
     return async function build({ workPath }) {
-        const opts = { cwd: workPath };
-        const files = await glob_1.default('**', opts);
         // 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);
-        // 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 further below is needed.
-        for (const file in files) {
-            if (shouldIgnorePath(file, ignoreFilter, true)) {
-                delete files[file];
+        // 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 entrypointPattern = `api/**/*${ext}`;
-        const entrypoints = await glob_1.default(entrypointPattern, opts);
         const pages = {};
         const pluginName = packageName.replace('vercel-plugin-', '');
         const traceDir = path_1.join(workPath, `.output`, `inputs`, 
@@ -32805,9 +32824,11 @@ function convertRuntimeToPlugin(buildRuntime, packageName, ext) {
         // need to be able to easily inspect the output.
         `api-routes-${pluginName}`);
         await fs_extra_1.default.ensureDir(traceDir);
+        let newPathsRuntime = new Set();
+        let linkersRuntime = [];
         for (const entrypoint of Object.keys(entrypoints)) {
             const { output } = await buildRuntime({
-                files,
+                files: sourceFilesPreBuild,
                 entrypoint,
                 workPath,
                 config: {
@@ -32817,14 +32838,21 @@ function convertRuntimeToPlugin(buildRuntime, packageName, ext) {
                     avoidTopLevelInstall: true,
                 },
             });
-            pages[entrypoint] = {
-                handler: output.handler,
-                runtime: output.runtime,
-                memory: output.memory,
-                maxDuration: output.maxDuration,
-                environment: output.environment,
-                allowQuery: output.allowQuery,
-            };
+            // Legacy Runtimes tend to pollute the `workPath` with compiled results,
+            // because the `workPath` used to be a place that was a place where they could
+            // just put anything, but nowadays it's the working directory of the `vercel build`
+            // command, which is the place where the developer keeps their source files,
+            // so we don't want to pollute this space unnecessarily. That means we have to clean
+            // up files that were created by the build, which is done further below.
+            const sourceFilesAfterBuild = await getSourceFiles(workPath, ignoreFilter);
+            // Further down, we will need the filename of the Lambda handler
+            // for placing it inside `server/pages/api`, but because Legacy Runtimes
+            // don't expose the filename directly, we have to construct it
+            // from the handler name, and then find the matching file further below,
+            // because we don't yet know its extension here.
+            const handler = output.handler;
+            const handlerMethod = handler.split('.').reverse()[0];
+            const handlerFileName = handler.replace(`.${handlerMethod}`, '');
             // @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
@@ -32836,35 +32864,156 @@ function convertRuntimeToPlugin(buildRuntime, packageName, ext) {
                     delete lambdaFiles[file];
                 }
             }
+            const handlerFilePath = Object.keys(lambdaFiles).find(item => {
+                return path_1.parse(item).name === handlerFileName;
+            });
+            const handlerFileOrigin = lambdaFiles[handlerFilePath || ''].fsPath;
+            if (!handlerFileOrigin) {
+                throw new Error(`Could not find a handler file. Please ensure that the list of \`files\` defined for the returned \`Lambda\` contains a file with the name ${handlerFileName} (+ any extension).`);
+            }
             const entry = path_1.join(workPath, '.output', 'server', 'pages', entrypoint);
+            // We never want to link here, only copy, because the launcher
+            // file often has the same name for every entrypoint, which means that
+            // every build for every entrypoint overwrites the launcher of the previous
+            // one, so linking would end with a broken reference.
             await fs_extra_1.default.ensureDir(path_1.dirname(entry));
-            await linkOrCopy(files[entrypoint].fsPath, entry);
+            await fs_extra_1.default.copy(handlerFileOrigin, entry);
+            const newFilesEntrypoint = [];
+            const newDirectoriesEntrypoint = [];
+            const preBuildFiles = Object.values(sourceFilesPreBuild).map(file => {
+                return file.fsPath;
+            });
+            // Generate a list of directories and files that weren't present
+            // before the entrypoint was processed by the Legacy Runtime, so
+            // that we can perform a cleanup later. We need to divide into files
+            // and directories because only cleaning up files might leave empty
+            // directories, and listing directories separately also speeds up the
+            // build because we can just delete them, which wipes all of their nested
+            // paths, instead of iterating through all files that should be deleted.
+            for (const file in sourceFilesAfterBuild) {
+                if (!sourceFilesPreBuild[file]) {
+                    const path = sourceFilesAfterBuild[file].fsPath;
+                    const dirPath = path_1.dirname(path);
+                    // If none of the files that were present before the entrypoint
+                    // was processed are contained within the directory we're looking
+                    // at right now, then we know it's a newly added directory
+                    // and it can therefore be removed later on.
+                    const isNewDir = !preBuildFiles.some(filePath => {
+                        return path_1.dirname(filePath).startsWith(dirPath);
+                    });
+                    // Check out the list of tracked directories that were
+                    // newly added and see if one of them contains the path
+                    // we're looking at.
+                    const hasParentDir = newDirectoriesEntrypoint.some(dir => {
+                        return path.startsWith(dir);
+                    });
+                    // If we have already tracked a directory that was newly
+                    // added that sits above the file or directory that we're
+                    // looking at, we don't need to add more entries to the list
+                    // because when the parent will get removed in the future,
+                    // all of its children (and therefore the path we're looking at)
+                    // will automatically get removed anyways.
+                    if (hasParentDir) {
+                        continue;
+                    }
+                    if (isNewDir) {
+                        newDirectoriesEntrypoint.push(dirPath);
+                    }
+                    else {
+                        newFilesEntrypoint.push(path);
+                    }
+                }
+            }
             const tracedFiles = [];
-            Object.entries(lambdaFiles).forEach(async ([relPath, file]) => {
+            const linkers = Object.entries(lambdaFiles).map(async ([relPath, file]) => {
                 const newPath = path_1.join(traceDir, relPath);
+                // The handler was already moved into position above.
+                if (relPath === handlerFilePath) {
+                    return;
+                }
                 tracedFiles.push({ absolutePath: newPath, relativePath: relPath });
-                if (file.fsPath) {
-                    await linkOrCopy(file.fsPath, newPath);
+                const { fsPath, type } = file;
+                if (fsPath) {
+                    await fs_extra_1.default.ensureDir(path_1.dirname(newPath));
+                    const isNewFile = newFilesEntrypoint.includes(fsPath);
+                    const isInsideNewDirectory = newDirectoriesEntrypoint.some(dirPath => {
+                        return fsPath.startsWith(dirPath);
+                    });
+                    // With this, we're making sure that files in the `workPath` that existed
+                    // before the Legacy Runtime was invoked (source files) are linked from
+                    // `.output` instead of copying there (the latter only happens if linking fails),
+                    // which is the fastest solution. However, files that are created fresh
+                    // by the Legacy Runtimes are always copied, because their link destinations
+                    // are likely to be overwritten every time an entrypoint is processed by
+                    // the Legacy Runtime. This is likely to overwrite the destination on subsequent
+                    // runs, but that's also how `workPath` used to work originally, without
+                    // the File System API (meaning that there was one `workPath` for all entrypoints).
+                    if (isNewFile || isInsideNewDirectory) {
+                        _1.debug(`Copying from ${fsPath} to ${newPath}`);
+                        await fs_extra_1.default.copy(fsPath, newPath);
+                    }
+                    else {
+                        await linkOrCopy(fsPath, newPath);
+                    }
                 }
-                else if (file.type === 'FileBlob') {
+                else if (type === 'FileBlob') {
                     const { data, mode } = file;
                     await fs_extra_1.default.writeFile(newPath, data, { mode });
                 }
                 else {
-                    throw new Error(`Unknown file type: ${file.type}`);
+                    throw new Error(`Unknown file type: ${type}`);
                 }
             });
+            linkersRuntime = linkersRuntime.concat(linkers);
             const nft = path_1.join(workPath, '.output', 'server', 'pages', `${entrypoint}.nft.json`);
             const json = JSON.stringify({
                 version: 1,
-                files: tracedFiles.map(f => ({
-                    input: normalize_path_1.normalizePath(path_1.relative(nft, f.absolutePath)),
-                    output: normalize_path_1.normalizePath(f.relativePath),
+                files: tracedFiles.map(file => ({
+                    input: normalize_path_1.normalizePath(path_1.relative(path_1.dirname(nft), file.absolutePath)),
+                    output: normalize_path_1.normalizePath(file.relativePath),
                 })),
             });
             await fs_extra_1.default.ensureDir(path_1.dirname(nft));
             await fs_extra_1.default.writeFile(nft, json);
+            // Extend the list of directories and files that were created by the
+            // Legacy Runtime with the list of directories and files that were
+            // created for the entrypoint that was just processed above.
+            newPathsRuntime = new Set([
+                ...newPathsRuntime,
+                ...newFilesEntrypoint,
+                ...newDirectoriesEntrypoint,
+            ]);
+            const apiRouteHandler = `${path_1.parse(entry).name}.${handlerMethod}`;
+            // Add an entry that will later on be added to the `functions-manifest.json`
+            // file that is placed inside of the `.output` directory.
+            pages[entrypoint] = {
+                handler: apiRouteHandler,
+                runtime: output.runtime,
+                memory: output.memory,
+                maxDuration: output.maxDuration,
+                environment: output.environment,
+                allowQuery: output.allowQuery,
+            };
         }
+        // Instead of of waiting for all of the linking to be done for every
+        // entrypoint before processing the next one, we immediately handle all
+        // of them one after the other, while then waiting for the linking
+        // to finish right here, before we clean up newly created files below.
+        await Promise.all(linkersRuntime);
+        // A list of all the files that were created by the Legacy Runtime,
+        // which we'd like to remove from the File System.
+        const toRemove = Array.from(newPathsRuntime).map(path => {
+            _1.debug(`Removing ${path} as part of cleanup`);
+            return fs_extra_1.default.remove(path);
+        });
+        // Once all the entrypoints have been processed, we'd like to
+        // remove all the files from `workPath` that originally weren't present
+        // before the Legacy Runtime began running, because the `workPath`
+        // is nowadays the directory in which the user keeps their source code, since
+        // we're no longer running separate parallel builds for every Legacy Runtime.
+        await Promise.all(toRemove);
+        // Add any Serverless Functions that were exposed by the Legacy Runtime
+        // to the `functions-manifest.json` file provided in `.output`.
         await updateFunctionsManifest({ workPath, pages });
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/build-utils",
-  "version": "2.12.3-canary.30",
+  "version": "2.12.3-canary.34",
   "license": "MIT",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",
@@ -49,5 +49,5 @@
     "typescript": "4.3.4",
     "yazl": "2.4.3"
   },
-  "gitHead": "9227471acaa7102c0e37b338c6ebcc05cbc95486"
+  "gitHead": "34f4222ca2d3cc5134469daa355a7f67c2054c9b"
 }