Publish Canary

- @vercel/build-utils@2.12.3-canary.35
 - vercel@23.1.3-canary.58
 - @vercel/client@10.2.3-canary.36
 - vercel-plugin-middleware@0.0.0-canary.11
 - vercel-plugin-go@1.0.0-canary.23
 - vercel-plugin-node@1.12.2-canary.27
 - vercel-plugin-python@1.0.0-canary.24
 - vercel-plugin-ruby@1.0.0-canary.23
 - @vercel/ruby@1.2.10-canary.0

.github/CODEOWNERS

@@ -4,24 +4,26 @@
 *                                        @TooTallNate
 /.github/workflows                       @AndyBitz @styfle
 /packages/frameworks                     @AndyBitz
+/packages/cli/src/commands/build         @TooTallNate @styfle @AndyBitz @gdborton @jaredpalmer
 /packages/cli/src/commands/dev           @TooTallNate @styfle @AndyBitz
 /packages/cli/src/util/dev               @TooTallNate @styfle @AndyBitz
 /packages/cli/src/commands/domains       @javivelasco @mglagola @anatrajkovska
 /packages/cli/src/commands/certs         @javivelasco @mglagola @anatrajkovska
 /packages/cli/src/commands/env           @styfle @lucleray
-/packages/client                     @rdev @styfle @TooTallNate
+/packages/client                         @styfle @TooTallNate
 /packages/build-utils                    @styfle @AndyBitz @TooTallNate
+/packages/middleware                     @gdborton @javivelasco
 /packages/node                           @styfle @TooTallNate @lucleray
 /packages/node-bridge                    @styfle @TooTallNate @lucleray
 /packages/next                           @Timer @ijjk
 /packages/go                             @styfle @TooTallNate
 /packages/python                         @styfle @TooTallNate
-/packages/ruby                       @styfle @coetry @TooTallNate
+/packages/ruby                           @styfle @TooTallNate
 /packages/static-build                   @styfle @AndyBitz
 /packages/routing-utils                  @styfle @dav-is @ijjk
-/examples                                @mcsdevv @timothyis
+/examples                                @mcsdevv
 /examples/create-react-app               @Timer
 /examples/nextjs                         @timneutkens @Timer
-/examples/hugo                           @mcsdevv @timothyis @styfle
-/examples/jekyll                         @mcsdevv @timothyis @styfle
-/examples/zola                           @mcsdevv @timothyis @styfle
+/examples/hugo                           @mcsdevv @styfle
+/examples/jekyll                         @mcsdevv @styfle
+/examples/zola                           @mcsdevv @styfle

packages/build-utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/build-utils",
-  "version": "2.12.3-canary.32",
+  "version": "2.12.3-canary.35",
   "license": "MIT",
   "main": "./dist/index.js",
   "types": "./dist/index.d.js",

packages/build-utils/src/convert-runtime-to-plugin.ts

@@ -1,11 +1,11 @@
 import fs from 'fs-extra';
-import { join, dirname, parse, relative } from 'path';
+import { join, parse, relative, dirname, basename, extname } from 'path';
 import glob from './fs/glob';
 import { normalizePath } from './fs/normalize-path';
 import { FILES_SYMBOL, Lambda } from './lambda';
 import type FileBlob from './file-blob';
 import type { BuildOptions, Files } from './types';
-import { getIgnoreFilter } from '.';
+import { debug, getIgnoreFilter } from '.';
 
 // `.output` was already created by the Build Command, so we have
 // to ensure its contents don't get bundled into the Lambda. Similarily,
@@ -101,6 +101,9 @@ export function convertRuntimeToPlugin(
 
     await fs.ensureDir(traceDir);
 
+    let newPathsRuntime: Set<string> = new Set();
+    let linkersRuntime: Array<Promise<void>> = [];
+
     for (const entrypoint of Object.keys(entrypoints)) {
       const { output } = await buildRuntime({
         files: sourceFilesPreBuild,
@@ -125,24 +128,6 @@ export function convertRuntimeToPlugin(
         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}`, '');
-
-      pages[entrypoint] = {
-        handler: handler,
-        runtime: output.runtime,
-        memory: output.memory,
-        maxDuration: output.maxDuration,
-        environment: output.environment,
-        allowQuery: output.allowQuery,
-      };
-
       // @ts-ignore This symbol is a private API
       const lambdaFiles: Files = output[FILES_SYMBOL];
 
@@ -156,69 +141,151 @@ export function convertRuntimeToPlugin(
         }
       }
 
-      const handlerFilePath = Object.keys(lambdaFiles).find(item => {
-        return parse(item).name === handlerFileName;
-      });
+      let handlerFileBase = output.handler;
+      let handlerFile = lambdaFiles[handlerFileBase];
 
-      const handlerFileOrigin = lambdaFiles[handlerFilePath || ''].fsPath;
+      const { handler } = output;
+      const handlerMethod = handler.split('.').pop();
+      const handlerFileName = handler.replace(`.${handlerMethod}`, '');
 
-      if (!handlerFileOrigin) {
+      // 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];
+      }
+
+      if (!handlerFile || !handlerFile.fsPath) {
         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).`
+          `Could not find a handler file. Please ensure that \`files\` for the returned \`Lambda\` contains an \`FileFsRef\` named "${handlerFileBase}" with a valid \`fsPath\`.`
         );
       }
 
-      const entry = join(workPath, '.output', 'server', 'pages', entrypoint);
+      const handlerExtName = extname(handlerFile.fsPath);
 
+      const entryRoot = join(workPath, '.output', 'server', 'pages');
+      const entryBase = basename(entrypoint).replace(ext, handlerExtName);
+      const entryPath = join(dirname(entrypoint), entryBase);
+      const entry = join(entryRoot, entryPath);
+
+      // 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.ensureDir(dirname(entry));
-      await linkOrCopy(handlerFileOrigin, entry);
+      await fs.copy(handlerFile.fsPath, entry);
 
-      const toRemove = [];
+      const newFilesEntrypoint: Array<string> = [];
+      const newDirectoriesEntrypoint: Array<string> = [];
 
-      // You can find more details about this at the point where the
-      // `sourceFilesAfterBuild` is created originally.
+      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;
-          toRemove.push(fs.remove(path));
-        }
+          const dirPath = 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 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;
           }
 
-      await Promise.all(toRemove);
+          if (isNewDir) {
+            newDirectoriesEntrypoint.push(dirPath);
+          } else {
+            newFilesEntrypoint.push(path);
+          }
+        }
+      }
 
       const tracedFiles: {
         absolutePath: string;
         relativePath: string;
       }[] = [];
 
-      Object.entries(lambdaFiles).forEach(async ([relPath, file]) => {
+      const linkers = Object.entries(lambdaFiles).map(
+        async ([relPath, file]) => {
           const newPath = join(traceDir, relPath);
 
           // The handler was already moved into position above.
-        if (relPath === handlerFilePath) {
+          if (relPath === handlerFileBase) {
             return;
           }
 
           tracedFiles.push({ absolutePath: newPath, relativePath: relPath });
+          const { fsPath, type } = file;
 
-        if (file.fsPath) {
-          await linkOrCopy(file.fsPath, newPath);
-        } else if (file.type === 'FileBlob') {
+          if (fsPath) {
+            await fs.ensureDir(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) {
+              debug(`Copying from ${fsPath} to ${newPath}`);
+              await fs.copy(fsPath, newPath);
+            } else {
+              await linkOrCopy(fsPath, newPath);
+            }
+          } else if (type === 'FileBlob') {
             const { data, mode } = file as FileBlob;
             await fs.writeFile(newPath, data, { mode });
           } else {
-          throw new Error(`Unknown file type: ${file.type}`);
+            throw new Error(`Unknown file type: ${type}`);
+          }
         }
-      });
-
-      const nft = join(
-        workPath,
-        '.output',
-        'server',
-        'pages',
-        `${entrypoint}.nft.json`
       );
 
+      linkersRuntime = linkersRuntime.concat(linkers);
+
+      const nft = `${entry}.nft.json`;
+
       const json = JSON.stringify({
         version: 1,
         files: tracedFiles.map(file => ({
@@ -229,8 +296,54 @@ export function convertRuntimeToPlugin(
 
       await fs.ensureDir(dirname(nft));
       await fs.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,
+      ]);
+
+      // Add an entry that will later on be added to the `functions-manifest.json`
+      // file that is placed inside of the `.output` directory.
+      pages[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, parse(entry).name),
+        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 => {
+      debug(`Removing ${path} as part of cleanup`);
+      return fs.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 });
   };
 }

packages/build-utils/test/unit.convert-runtime-to-plugin.test.ts

@@ -98,9 +98,13 @@ describe('convert-runtime-to-plugin', () => {
     expect(funcManifest).toMatchObject({
       version: 1,
       pages: {
-        'api/index.py': lambdaOptions,
-        'api/users/get.py': lambdaOptions,
-        'api/users/post.py': { ...lambdaOptions, memory: 512 },
+        'api/index.py': { ...lambdaOptions, handler: 'index.vc_handler' },
+        'api/users/get.py': { ...lambdaOptions, handler: 'get.vc_handler' },
+        'api/users/post.py': {
+          ...lambdaOptions,
+          handler: 'post.vc_handler',
+          memory: 512,
+        },
       },
     });
 

packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vercel",
-  "version": "23.1.3-canary.53",
+  "version": "23.1.3-canary.58",
   "preferGlobal": true,
   "license": "Apache-2.0",
   "description": "The command-line interface for Vercel",
@@ -43,14 +43,14 @@
     "node": ">= 12"
   },
   "dependencies": {
-    "@vercel/build-utils": "2.12.3-canary.32",
+    "@vercel/build-utils": "2.12.3-canary.35",
     "@vercel/go": "1.2.4-canary.4",
     "@vercel/node": "1.12.2-canary.7",
     "@vercel/python": "2.1.2-canary.1",
-    "@vercel/ruby": "1.2.8-canary.6",
+    "@vercel/ruby": "1.2.10-canary.0",
     "update-notifier": "4.1.0",
-    "vercel-plugin-middleware": "0.0.0-canary.7",
-    "vercel-plugin-node": "1.12.2-canary.24"
+    "vercel-plugin-middleware": "0.0.0-canary.11",
+    "vercel-plugin-node": "1.12.2-canary.27"
   },
   "devDependencies": {
     "@next/env": "11.1.2",

packages/cli/src/commands/build.ts

@@ -5,6 +5,7 @@ import {
   GlobOptions,
   scanParentDirs,
   spawnAsync,
+  glob as buildUtilsGlob,
 } from '@vercel/build-utils';
 import { nodeFileTrace } from '@vercel/nft';
 import Sema from 'async-sema';
@@ -355,8 +356,13 @@ export default async function main(client: Client) {
     // We cannot rely on the `framework` alone, as it might be a static export,
     // and the current build might use a differnt project that's not in the settings.
     const isNextOutput = Boolean(dotNextDir);
-    const outputDir = isNextOutput ? OUTPUT_DIR : join(OUTPUT_DIR, 'static');
+    const nextExport = await getNextExportStatus(dotNextDir);
+    const outputDir =
+      isNextOutput && !nextExport ? OUTPUT_DIR : join(OUTPUT_DIR, 'static');
     const distDir =
+      (nextExport?.exportDetail.outDirectory
+        ? relative(cwd, nextExport.exportDetail.outDirectory)
+        : false) ||
       dotNextDir ||
       userOutputDirectory ||
       (await framework.getFsOutputDir(cwd));
@@ -443,7 +449,53 @@ export default async function main(client: Client) {
     }
 
     // Special Next.js processing.
-    if (isNextOutput) {
+    if (nextExport) {
+      client.output.debug('Found `next export` output.');
+
+      const htmlFiles = await buildUtilsGlob(
+        '**/*.html',
+        join(cwd, OUTPUT_DIR, 'static')
+      );
+
+      if (nextExport.exportDetail.success !== true) {
+        client.output.error(
+          `Export of Next.js app failed. Please check your build logs.`
+        );
+        process.exit(1);
+      }
+
+      await fs.mkdirp(join(cwd, OUTPUT_DIR, 'server', 'pages'));
+      await fs.mkdirp(join(cwd, OUTPUT_DIR, 'static'));
+
+      await Promise.all(
+        Object.keys(htmlFiles).map(async fileName => {
+          await sema.acquire();
+
+          const input = join(cwd, OUTPUT_DIR, 'static', fileName);
+          const target = join(cwd, OUTPUT_DIR, 'server', 'pages', fileName);
+
+          await fs.mkdirp(dirname(target));
+
+          await fs.promises.rename(input, target).finally(() => {
+            sema.release();
+          });
+        })
+      );
+
+      for (const file of [
+        'BUILD_ID',
+        'images-manifest.json',
+        'routes-manifest.json',
+        'build-manifest.json',
+      ]) {
+        const input = join(nextExport.dotNextDir, file);
+
+        if (fs.existsSync(input)) {
+          // Do not use `smartCopy`, since we want to overwrite if they already exist.
+          await fs.copyFile(input, join(OUTPUT_DIR, file));
+        }
+      }
+    } else if (isNextOutput) {
       // The contents of `.output/static` should be placed inside of `.output/static/_next/static`
       const tempStatic = '___static';
       await fs.rename(
@@ -877,3 +929,53 @@ async function resolveNftToOutput({
     files: newFilesList,
   });
 }
+
+/**
+ * Files will only exist when `next export` was used.
+ */
+async function getNextExportStatus(dotNextDir: string | null) {
+  if (!dotNextDir) {
+    return null;
+  }
+
+  const exportDetail: {
+    success: boolean;
+    outDirectory: string;
+  } | null = await fs
+    .readJson(join(dotNextDir, 'export-detail.json'))
+    .catch(error => {
+      if (error.code === 'ENOENT') {
+        return null;
+      }
+
+      throw error;
+    });
+
+  if (!exportDetail) {
+    return null;
+  }
+
+  const exportMarker: {
+    version: 1;
+    exportTrailingSlash: boolean;
+    hasExportPathMap: boolean;
+  } | null = await fs
+    .readJSON(join(dotNextDir, 'export-marker.json'))
+    .catch(error => {
+      if (error.code === 'ENOENT') {
+        return null;
+      }
+
+      throw error;
+    });
+
+  return {
+    dotNextDir,
+    exportDetail,
+    exportMarker: {
+      trailingSlash: exportMarker?.hasExportPathMap
+        ? exportMarker.exportTrailingSlash
+        : false,
+    },
+  };
+}

packages/cli/test/fixtures/unit/edge-middleware-strict/_middleware.ts

@@ -0,0 +1,6 @@
+export default function (req) {
+  const isStrict = (function () {
+    return !this;
+  })();
+  return new Response('is strict mode? ' + (isStrict ? 'yes' : 'no'));
+}

packages/cli/test/util/dev/server.test.ts

@@ -385,4 +385,13 @@ describe('DevServer', () => {
       );
     })
   );
+
+  it(
+    'should run middleware in strict mode',
+    testFixture('edge-middleware-strict', async server => {
+      const response = await fetch(`${server.address}/index.html`);
+      const body = await response.text();
+      expect(body).toStrictEqual('is strict mode? yes');
+    })
+  );
 });

packages/client/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/client",
-  "version": "10.2.3-canary.33",
+  "version": "10.2.3-canary.36",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "homepage": "https://vercel.com",
@@ -40,7 +40,7 @@
     ]
   },
   "dependencies": {
-    "@vercel/build-utils": "2.12.3-canary.32",
+    "@vercel/build-utils": "2.12.3-canary.35",
     "@zeit/fetch": "5.2.0",
     "async-retry": "1.2.3",
     "async-sema": "3.0.0",

packages/middleware/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vercel-plugin-middleware",
-  "version": "0.0.0-canary.7",
+  "version": "0.0.0-canary.11",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "",
@@ -30,6 +30,7 @@
     "@types/node-fetch": "^2",
     "@types/ua-parser-js": "0.7.36",
     "@types/uuid": "8.3.1",
+    "@vercel/build-utils": "2.12.3-canary.35",
     "@vercel/ncc": "0.24.0",
     "cookie": "0.4.1",
     "formdata-node": "4.3.1",

packages/middleware/src/entries.js

@@ -1,4 +1,4 @@
-import * as middleware from './_middleware';
+import * as middleware from './_temp_middleware';
 _ENTRIES = typeof _ENTRIES === 'undefined' ? {} : _ENTRIES;
 _ENTRIES['middleware_pages/_middleware'] = {
   default: async function (ev) {

packages/middleware/src/index.ts

@@ -5,6 +5,7 @@ import { promises as fsp } from 'fs';
 import { IncomingMessage, ServerResponse } from 'http';
 import libGlob from 'glob';
 import Proxy from 'http-proxy';
+import { updateFunctionsManifest } from '@vercel/build-utils';
 
 import { run } from './websandbox';
 import type { FetchEventResult } from './websandbox/types';
@@ -22,7 +23,8 @@ const SUPPORTED_EXTENSIONS = ['.js', '.ts'];
 
 // File name of the `entries.js` file that gets copied into the
 // project directory. Use a name that is unlikely to conflict.
-const ENTRIES_NAME = '___vc_entries.js';
+const TMP_ENTRIES_NAME = '.output/inputs/middleware/___vc_entries.js';
+const TMP_MIDDLEWARE_BUNDLE = '.output/inputs/middleware/_temp_middleware.js';
 
 async function getMiddlewareFile(workingDirectory: string) {
   // Only the root-level `_middleware.*` files are considered.
@@ -52,17 +54,36 @@ async function getMiddlewareFile(workingDirectory: string) {
 }
 
 export async function build({ workPath }: { workPath: string }) {
-  const entriesPath = join(workPath, ENTRIES_NAME);
+  const entriesPath = join(workPath, TMP_ENTRIES_NAME);
+  const transientFilePath = join(workPath, TMP_MIDDLEWARE_BUNDLE);
   const middlewareFile = await getMiddlewareFile(workPath);
   if (!middlewareFile) return;
 
   console.log('Compiling middleware file: %j', middlewareFile);
 
+  /**
+   * Two builds happen here, because esbuild doesn't offer a way to add a banner
+   * to individual input files, and the entries wrapper relies on running in
+   * non-strict mode to access the ENTRIES global.
+   *
+   * To work around this, we bundle the middleware directly and add
+   * 'use strict'; to make the entire bundle run in strict mode. We then bundle
+   * a second time, adding the global ENTRIES wrapper and preserving the
+   * 'use strict' for the entire scope of the original bundle.
+   */
+  try {
+    await esbuild.build({
+      entryPoints: [middlewareFile],
+      bundle: true,
+      absWorkingDir: workPath,
+      outfile: transientFilePath,
+      banner: {
+        js: '"use strict";',
+      },
+      format: 'cjs',
+    });
     // Create `_ENTRIES` wrapper
     await fsp.copyFile(join(__dirname, 'entries.js'), entriesPath);
-
-  // Build
-  try {
     await esbuild.build({
       entryPoints: [entriesPath],
       bundle: true,
@@ -70,29 +91,24 @@ export async function build({ workPath }: { workPath: string }) {
       outfile: join(workPath, '.output/server/pages/_middleware.js'),
     });
   } finally {
+    await fsp.unlink(transientFilePath);
     await fsp.unlink(entriesPath);
   }
 
-  // Write middleware manifest
-  const middlewareManifest = {
-    version: 1,
-    sortedMiddleware: ['/'],
-    middleware: {
-      '/': {
+  const fileName = basename(middlewareFile);
+  const pages: { [key: string]: any } = {};
+
+  pages[fileName] = {
+    runtime: 'web',
     env: [],
     files: ['server/pages/_middleware.js'],
     name: 'pages/_middleware',
     page: '/',
     regexp: '^/.*$',
-      },
-    },
+    sortingIndex: 1,
   };
-  const middlewareManifestData = JSON.stringify(middlewareManifest, null, 2);
-  const middlewareManifestPath = join(
-    workPath,
-    '.output/server/middleware-manifest.json'
-  );
-  await fsp.writeFile(middlewareManifestPath, middlewareManifestData);
+
+  await updateFunctionsManifest({ workPath, pages });
 }
 
 const stringifyQuery = (req: IncomingMessage, query: ParsedUrlQuery) => {

packages/middleware/src/websandbox/sandbox/sandbox.ts

@@ -114,6 +114,7 @@ export async function run(params: {
     const content = readFileSync(params.path, 'utf-8');
     const esBuildResult = esbuild.transformSync(content, {
       format: 'cjs',
+      banner: '"use strict";',
     });
     const x = vm.runInNewContext(m.wrap(esBuildResult.code), cache.sandbox, {
       filename: params.path,
@@ -163,6 +164,7 @@ function sandboxRequire(referrer: string, specifier: string) {
 
   const transformOptions: esbuild.TransformOptions = {
     format: 'cjs',
+    banner: '"use strict";',
   };
   if (extname(resolved) === '.json') {
     transformOptions.loader = 'json';

packages/middleware/test/__snapshots__/build.test.ts.snap

@@ -2,8 +2,8 @@
 
 exports[`build() should build simple middleware 1`] = `
 Object {
-  "middleware": Object {
-    "/": Object {
+  "pages": Object {
+    "_middleware.js": Object {
       "env": Array [],
       "files": Array [
         "server/pages/_middleware.js",
@@ -11,11 +11,10 @@ Object {
       "name": "pages/_middleware",
       "page": "/",
       "regexp": "^/.*$",
+      "runtime": "web",
+      "sortingIndex": 1,
     },
   },
-  "sortedMiddleware": Array [
-    "/",
-  ],
   "version": 1,
 }
 `;

packages/middleware/test/build.test.ts

@@ -3,6 +3,30 @@ import { promises as fsp } from 'fs';
 import { build } from '../src';
 import { Response } from 'node-fetch';
 
+const setupFixture = async (fixture: string) => {
+  const fixturePath = join(__dirname, `fixtures/${fixture}`);
+  await build({
+    workPath: fixturePath,
+  });
+
+  const functionsManifest = JSON.parse(
+    await fsp.readFile(
+      join(fixturePath, '.output/functions-manifest.json'),
+      'utf8'
+    )
+  );
+
+  const outputFile = join(fixturePath, '.output/server/pages/_middleware.js');
+  expect(await fsp.stat(outputFile)).toBeTruthy();
+  require(outputFile);
+  //@ts-ignore
+  const middleware = global._ENTRIES['middleware_pages/_middleware'].default;
+  return {
+    middleware,
+    functionsManifest,
+  };
+};
+
 describe('build()', () => {
   beforeEach(() => {
     //@ts-ignore
@@ -15,25 +39,9 @@ describe('build()', () => {
     delete global._ENTRIES;
   });
   it('should build simple middleware', async () => {
-    const fixture = join(__dirname, 'fixtures/simple');
-    await build({
-      workPath: fixture,
-    });
+    const { functionsManifest, middleware } = await setupFixture('simple');
 
-    const middlewareManifest = JSON.parse(
-      await fsp.readFile(
-        join(fixture, '.output/server/middleware-manifest.json'),
-        'utf8'
-      )
-    );
-    expect(middlewareManifest).toMatchSnapshot();
-
-    const outputFile = join(fixture, '.output/server/pages/_middleware.js');
-    expect(await fsp.stat(outputFile)).toBeTruthy();
-
-    require(outputFile);
-    //@ts-ignore
-    const middleware = global._ENTRIES['middleware_pages/_middleware'].default;
+    expect(functionsManifest).toMatchSnapshot();
     expect(typeof middleware).toStrictEqual('function');
     const handledResponse = await middleware({
       request: {
@@ -54,4 +62,12 @@ describe('build()', () => {
       (unhandledResponse.response as Response).headers.get('x-middleware-next')
     ).toEqual('1');
   });
+
+  it('should create a middleware that runs in strict mode', async () => {
+    const { middleware } = await setupFixture('use-strict');
+    const response = await middleware({
+      request: {},
+    });
+    expect(String(response.response.body)).toEqual('is strict mode? yes');
+  });
 });

packages/middleware/test/fixtures/use-strict/_middleware.js

@@ -0,0 +1,6 @@
+export default function (req) {
+  const isStrict = (function () {
+    return !this;
+  })();
+  return new Response('is strict mode? ' + (isStrict ? 'yes' : 'no'));
+}

packages/plugin-go/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "vercel-plugin-go",
-  "version": "1.0.0-canary.20",
+  "version": "1.0.0-canary.23",
   "main": "dist/index.js",
   "license": "MIT",
   "files": [
@@ -17,7 +17,7 @@
     "prepublishOnly": "tsc"
   },
   "dependencies": {
-    "@vercel/build-utils": "2.12.3-canary.32",
+    "@vercel/build-utils": "2.12.3-canary.35",
     "@vercel/go": "1.2.4-canary.4"
   },
   "devDependencies": {

packages/plugin-node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vercel-plugin-node",
-  "version": "1.12.2-canary.24",
+  "version": "1.12.2-canary.27",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/node-js",
@@ -34,7 +34,7 @@
     "@types/node-fetch": "2",
     "@types/test-listen": "1.1.0",
     "@types/yazl": "2.4.2",
-    "@vercel/build-utils": "2.12.3-canary.32",
+    "@vercel/build-utils": "2.12.3-canary.35",
     "@vercel/fun": "1.0.3",
     "@vercel/ncc": "0.24.0",
     "@vercel/nft": "0.14.0",

packages/plugin-python/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "vercel-plugin-python",
-  "version": "1.0.0-canary.21",
+  "version": "1.0.0-canary.24",
   "main": "dist/index.js",
   "license": "MIT",
   "files": [
@@ -17,7 +17,7 @@
     "prepublishOnly": "tsc"
   },
   "dependencies": {
-    "@vercel/build-utils": "2.12.3-canary.32",
+    "@vercel/build-utils": "2.12.3-canary.35",
     "@vercel/python": "2.1.2-canary.1"
   },
   "devDependencies": {

packages/plugin-ruby/package.json

@@ -1,7 +1,7 @@
 {
   "private": false,
   "name": "vercel-plugin-ruby",
-  "version": "1.0.0-canary.19",
+  "version": "1.0.0-canary.23",
   "main": "dist/index.js",
   "license": "MIT",
   "files": [
@@ -17,8 +17,8 @@
     "prepublishOnly": "tsc"
   },
   "dependencies": {
-    "@vercel/build-utils": "2.12.3-canary.32",
-    "@vercel/ruby": "1.2.8-canary.6"
+    "@vercel/build-utils": "2.12.3-canary.35",
+    "@vercel/ruby": "1.2.10-canary.0"
   },
   "devDependencies": {
     "@types/node": "*",

packages/ruby/install-ruby.ts

@@ -9,13 +9,24 @@ interface RubyVersion extends NodeVersion {
 
 const allOptions: RubyVersion[] = [
   { major: 2, minor: 7, range: '2.7.x', runtime: 'ruby2.7' },
-  { major: 2, minor: 5, range: '2.5.x', runtime: 'ruby2.5' },
+  {
+    major: 2,
+    minor: 5,
+    range: '2.5.x',
+    runtime: 'ruby2.5',
+    discontinueDate: new Date('2021-11-30'),
+  },
 ];
 
 function getLatestRubyVersion(): RubyVersion {
   return allOptions[0];
 }
 
+function isDiscontinued({ discontinueDate }: RubyVersion): boolean {
+  const today = Date.now();
+  return discontinueDate !== undefined && discontinueDate.getTime() <= today;
+}
+
 function getRubyPath(meta: Meta, gemfileContents: string) {
   let selection = getLatestRubyVersion();
   if (meta.isDev) {
@@ -37,8 +48,20 @@ function getRubyPath(meta: Meta, gemfileContents: string) {
       if (!found) {
         throw new NowBuildError({
           code: 'RUBY_INVALID_VERSION',
-          message: 'Found `Gemfile` with invalid Ruby version: `' + line + '`.',
-          link: 'https://vercel.com/docs/runtimes#official-runtimes/ruby/ruby-version',
+          message: `Found \`Gemfile\` with invalid Ruby version: \`${line}.\``,
+          link: 'http://vercel.link/ruby-version',
+        });
+      }
+      if (isDiscontinued(selection)) {
+        const latest = getLatestRubyVersion();
+        const intro = `Found \`Gemfile\` with discontinued Ruby version: \`${line}.\``;
+        const hint = `Please set \`ruby "~> ${latest.range}"\` in your \`Gemfile\` to use Ruby ${latest.range}.`;
+        const upstream =
+          'This change is the result of a decision made by an upstream infrastructure provider (AWS).';
+        throw new NowBuildError({
+          code: 'RUBY_DISCONTINUED_VERSION',
+          link: 'http://vercel.link/ruby-version',
+          message: `${intro} ${hint} ${upstream}`,
         });
       }
     }

packages/ruby/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vercel/ruby",
   "author": "Nathan Cahill <nathan@nathancahill.com>",
-  "version": "1.2.8-canary.6",
+  "version": "1.2.10-canary.0",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/ruby",

packages/ruby/test/fixtures/02-cowsay-vendored/now.json

@@ -1,6 +1,5 @@
 {
   "version": 2,
   "builds": [{ "src": "index.rb", "use": "@vercel/ruby" }],
-  "build": { "env": { "RUBY_VERSION": "2.7.x" } },
   "probes": [{ "path": "/", "mustContain": "gem:RANDOMNESS_PLACEHOLDER" }]
 }

packages/ruby/test/fixtures/04-cowsay-vendored-nested/now.json

@@ -1,7 +1,6 @@
 {
   "version": 2,
   "builds": [{ "src": "project/index.rb", "use": "@vercel/ruby" }],
-  "build": { "env": { "RUBY_VERSION": "2.7.x" } },
   "probes": [
     { "path": "/project/", "mustContain": "gem:RANDOMNESS_PLACEHOLDER" }
   ]

packages/ruby/test/fixtures/05-sinatra/now.json

@@ -1,6 +1,5 @@
 {
   "version": 2,
   "builds": [{ "src": "index.ru", "use": "@vercel/ruby" }],
-  "build": { "env": { "RUBY_VERSION": "2.7.x" } },
   "probes": [{ "path": "/", "mustContain": "gem:RANDOMNESS_PLACEHOLDER" }]
 }

packages/ruby/test/fixtures/11-version-2-5-error/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+ruby "~> 2.5.x"
+
+gem "cowsay", "~> 0.3.0"

packages/ruby/test/fixtures/11-version-2-5-error/Gemfile.lock

@@ -0,0 +1,16 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    cowsay (0.3.0)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  cowsay (~> 0.3.0)
+
+RUBY VERSION
+   ruby 2.5.5p157
+
+BUNDLED WITH
+   2.2.22

packages/ruby/test/fixtures/11-version-2-5-error/index.rb

@@ -0,0 +1,9 @@
+require 'cowsay'
+
+Handler = Proc.new do |req, res|
+  name = req.query['name'] || 'World'
+
+  res.status = 200
+  res['Content-Type'] = 'text/text; charset=utf-8'
+  res.body = Cowsay.say("Hello #{name}", 'cow')
+end

packages/ruby/test/fixtures/11-version-2-5-error/vercel.json

@@ -0,0 +1,4 @@
+{
+  "version": 2,
+  "builds": [{ "src": "index.rb", "use": "@vercel/ruby" }]
+}

packages/ruby/test/test.js

@@ -23,8 +23,32 @@ beforeAll(async () => {
 
 const fixturesPath = path.resolve(__dirname, 'fixtures');
 
+const testsThatFailToBuild = new Map([
+  [
+    '11-version-2-5-error',
+    'Found `Gemfile` with discontinued Ruby version: `ruby "~> 2.5.x".` Please set `ruby "~> 2.7.x"` in your `Gemfile` to use Ruby 2.7.x. This change is the result of a decision made by an upstream infrastructure provider (AWS).',
+  ],
+]);
+
 // eslint-disable-next-line no-restricted-syntax
 for (const fixture of fs.readdirSync(fixturesPath)) {
+  const errMsg = testsThatFailToBuild.get(fixture);
+  if (errMsg) {
+    // eslint-disable-next-line no-loop-func
+    it(`should fail to build ${fixture}`, async () => {
+      try {
+        await testDeployment(
+          { builderUrl, buildUtilsUrl },
+          path.join(fixturesPath, fixture)
+        );
+      } catch (err) {
+        expect(err).toBeTruthy();
+        expect(err.deployment).toBeTruthy();
+        expect(err.deployment.errorMessage).toBe(errMsg);
+      }
+    });
+    continue; //eslint-disable-line
+  }
   // eslint-disable-next-line no-loop-func
   it(`should build ${fixture}`, async () => {
     await expect(