Publish Stable

- @now/build-utils@1.3.2 - @now/next@2.3.7 - @now/node@1.3.3 - @now/static-build@0.14.3
Publish Canary
2025-12-24 03:39:11 +00:00 · 2020-01-06 18:44:26 -05:00 · 2020-01-06 18:30:34 -05:00 · 2020-01-06 18:29:08 -05:00 · 2020-01-06 17:01:47 -05:00 · 2020-01-06 17:00:46 -05:00
39 changed files with 1424 additions and 255 deletions
--- a/packages/frameworks/frameworks.json
+++ b/packages/frameworks/frameworks.json
@@ -12,6 +12,17 @@
          "matchContent": "\"(dev)?(d|D)ependencies\":\\s*{[^}]*\"next\":\\s*\".+?\"[^}]*}"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "placeholder": "`next build` or `build` from `package.json`"
+      },
+      "devCommand": {
+        "value": "next dev --port $PORT"
+      },
+      "outputDirectory": {
+        "placeholder": "Next.js default"
+      }
    }
  },
  {
@@ -27,6 +38,17 @@
          "matchContent": "\"(dev)?(d|D)ependencies\":\\s*{[^}]*\"gatsby\":\\s*\".+?\"[^}]*}"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "placeholder": "`gatsby build` or `build` from `package.json`"
+      },
+      "devCommand": {
+        "value": "gatsby develop --port $PORT"
+      },
+      "outputDirectory": {
+        "value": "public"
+      }
    }
  },
  {
@@ -41,6 +63,17 @@
          "matchContent": "\"(dev)?(d|D)ependencies\":\\s*{[^}]*\"hexo\":\\s*\".+?\"[^}]*}"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "placeholder": "`hexo generate` or `build` from `package.json`"
+      },
+      "devCommand": {
+        "value": "hexo server --port $PORT"
+      },
+      "outputDirectory": {
+        "value": "public"
+      }
    }
  },
  {
@@ -55,6 +88,17 @@
          "matchContent": "\"(dev)?(d|D)ependencies\":\\s*{[^}]*\"@11ty\\/eleventy\":\\s*\".+?\"[^}]*}"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "placeholder": "`npx @11ty/eleventy` or `build` from `package.json`"
+      },
+      "devCommand": {
+        "value": "npx @11ty/eleventy --serve --watch --port $PORT"
+      },
+      "outputDirectory": {
+        "value": "_site"
+      }
    }
  },
  {
@@ -73,6 +117,17 @@
          "matchContent": "\"(dev)?(d|D)ependencies\":\\s*{[^}]*\"@docusaurus\\/core\":\\s*\".+?\"[^}]*}"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "placeholder": "`docusaurus-build` or `build` from `package.json`"
+      },
+      "devCommand": {
+        "value": "docusaurus-start --port $PORT"
+      },
+      "outputDirectory": {
+        "value": "build"
+      }
    }
  },
  {
@@ -88,6 +143,17 @@
          "matchContent": "\"(dev)?(d|D)ependencies\":\\s*{[^}]*\"preact-cli\":\\s*\".+?\"[^}]*}"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "placeholder": "`preact build` or `build` from `package.json`"
+      },
+      "devCommand": {
+        "value": "preact watch --port $PORT"
+      },
+      "outputDirectory": {
+        "value": "build"
+      }
    }
  },
  {
@@ -102,6 +168,17 @@
          "matchContent": "\"(dev)?(d|D)ependencies\":\\s*{[^}]*\"ember-cli\":\\s*\".+?\"[^}]*}"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "placeholder": "`ember build` or `build` from `package.json`"
+      },
+      "devCommand": {
+        "value": "ember serve --port $PORT"
+      },
+      "outputDirectory": {
+        "value": "dist"
+      }
    }
  },
  {
@@ -117,6 +194,17 @@
          "matchContent": "\"(dev)?(d|D)ependencies\":\\s*{[^}]*\"@vue\\/cli-service\":\\s*\".+?\"[^}]*}"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "placeholder": "`vue-cli-service build` or `build` from `package.json`"
+      },
+      "devCommand": {
+        "value": "vue-cli-service serve --port $PORT"
+      },
+      "outputDirectory": {
+        "value": "dist"
+      }
    }
  },
  {
@@ -130,6 +218,17 @@
          "matchContent": "\"(dev)?(d|D)ependencies\":\\s*{[^}]*\"@scullyio\\/init\":\\s*\".+?\"[^}]*}"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "placeholder": "`ng build && scully` or `build` from `package.json`"
+      },
+      "devCommand": {
+        "value": "ng serve --port $PORT"
+      },
+      "outputDirectory": {
+        "value": "dist"
+      }
    }
  },
  {
@@ -145,6 +244,17 @@
          "matchContent": "\"(dev)?(d|D)ependencies\":\\s*{[^}]*\"@angular\\/cli\":\\s*\".+?\"[^}]*}"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "placeholder": "`ng build` or `build` from `package.json`"
+      },
+      "devCommand": {
+        "value": "ng serve --port $PORT"
+      },
+      "outputDirectory": {
+        "value": "dist"
+      }
    }
  },
  {
@@ -159,6 +269,17 @@
          "matchContent": "\"(dev)?(d|D)ependencies\":\\s*{[^}]*\"polymer-cli\":\\s*\".+?\"[^}]*}"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "placeholder": "`polymer build` or `build` from `package.json`"
+      },
+      "devCommand": {
+        "value": "polymer serve --port $PORT"
+      },
+      "outputDirectory": {
+        "value": "build"
+      }
    }
  },
  {
@@ -174,6 +295,17 @@
          "matchContent": "\"(dev)?(d|D)ependencies\":\\s*{[^}]*\"sirv-cli\":\\s*\".+?\"[^}]*}"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "placeholder": "`rollup -c` or `build` from `package.json`"
+      },
+      "devCommand": {
+        "value": "sirv public --single --dev --port $PORT"
+      },
+      "outputDirectory": {
+        "value": "public"
+      }
    }
  },
  {
@@ -193,6 +325,17 @@
          "matchContent": "\"(dev)?(d|D)ependencies\":\\s*{[^}]*\"react-dev-utils\":\\s*\".+?\"[^}]*}"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "placeholder": "`react-scripts build` or `build` from `package.json`"
+      },
+      "devCommand": {
+        "value": "react-scripts start"
+      },
+      "outputDirectory": {
+        "value": "build"
+      }
    }
  },
  {
@@ -207,6 +350,17 @@
          "matchContent": "\"(dev)?(d|D)ependencies\":\\s*{[^}]*\"gridsome\":\\s*\".+?\"[^}]*}"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "placeholder": "`gridsome build` or `build` from `package.json`"
+      },
+      "devCommand": {
+        "value": "gridsome develop -p $PORT"
+      },
+      "outputDirectory": {
+        "value": "dist"
+      }
    }
  },
  {
@@ -222,6 +376,17 @@
          "matchContent": "\"(dev)?(d|D)ependencies\":\\s*{[^}]*\"umi\":\\s*\".+?\"[^}]*}"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "placeholder": "`umi build` or `build` from `package.json`"
+      },
+      "devCommand": {
+        "value": "umi dev --port $PORT"
+      },
+      "outputDirectory": {
+        "value": "dist"
+      }
    }
  },
  {
@@ -237,6 +402,17 @@
          "matchContent": "\"(dev)?(d|D)ependencies\":\\s*{[^}]*\"sapper\":\\s*\".+?\"[^}]*}"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "placeholder": "`sapper export` or `build` from `package.json`"
+      },
+      "devCommand": {
+        "value": "sapper dev --port $PORT"
+      },
+      "outputDirectory": {
+        "value": "__sapper__/export"
+      }
    }
  },
  {
@@ -251,6 +427,17 @@
          "matchContent": "\"(dev)?(d|D)ependencies\":\\s*{[^}]*\"saber\":\\s*\".+?\"[^}]*}"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "placeholder": "`saber build` or `build` from `package.json`"
+      },
+      "devCommand": {
+        "value": "saber --port $PORT"
+      },
+      "outputDirectory": {
+        "value": "public"
+      }
    }
  },
  {
@@ -265,6 +452,17 @@
          "matchContent": "\"(dev)?(d|D)ependencies\":\\s*{[^}]*\"@stencil\\/core\":\\s*\".+?\"[^}]*}"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "placeholder": "`stencil build` or `build` from `package.json`"
+      },
+      "devCommand": {
+        "value": "stencil build --dev --watch --serve --port $PORT"
+      },
+      "outputDirectory": {
+        "value": "www"
+      }
    }
  },
  {
@@ -280,6 +478,17 @@
          "matchContent": "\"(dev)?(d|D)ependencies\":\\s*{[^}]*\"nuxt\":\\s*\".+?\"[^}]*}"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "placeholder": "`nuxt build` or `build` from `package.json`"
+      },
+      "devCommand": {
+        "value": "nuxt"
+      },
+      "outputDirectory": {
+        "value": "dist"
+      }
    }
  },
  {
@@ -300,6 +509,17 @@
          "file": "config.json"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "value": "hugo"
+      },
+      "devCommand": {
+        "value": "hugo server -D -w -p $PORT"
+      },
+      "outputDirectory": {
+        "placeholder": "`public` or `publishDir` from the `config` file"
+      }
    }
  },
  {
@@ -313,6 +533,17 @@
          "file": "_config.yml"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "value": "jekyll build"
+      },
+      "devCommand": {
+        "value": "bundle exec jekyll serve --watch --port $PORT"
+      },
+      "outputDirectory": {
+        "placeholder": "`_site` or `destination` from `_config.yml`"
+      }
    }
  },
  {
@@ -326,6 +557,17 @@
          "file": "brunch-config.js"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "placeholder": "`brunch build --production` or `build` from `package.json`"
+      },
+      "devCommand": {
+        "value": "brunch watch --server --port $PORT"
+      },
+      "outputDirectory": {
+        "value": "public"
+      }
    }
  },
  {
@@ -339,6 +581,17 @@
          "file": "config.rb"
        }
      ]
+    },
+    "settings": {
+      "buildCommand": {
+        "value": "bundle exec middleman build"
+      },
+      "devCommand": {
+        "value": "bundle exec middleman server -p $PORT"
+      },
+      "outputDirectory": {
+        "value": "build"
+      }
    }
  },
  {
--- a/packages/frameworks/index.d.ts
+++ b/packages/frameworks/index.d.ts
@@ -3,6 +3,11 @@ export interface FrameworkDetectionItem {
  matchContent?: string;
 }

+interface Setting {
+  value?: string;
+  placeholder?: string;
+}
+
 export interface Framework {
  name: string;
  slug: string;
@@ -13,4 +18,9 @@ export interface Framework {
    every?: FrameworkDetectionItem[];
    some?: FrameworkDetectionItem[];
  };
+  settings?: {
+    buildCommand?: Setting;
+    devCommand?: Setting;
+    outputDirectory?: Setting;
+  };
 }
--- a/packages/frameworks/package.json
+++ b/packages/frameworks/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@now/frameworks",
-  "version": "0.0.2",
+  "version": "0.0.3",
  "main": "frameworks.json",
  "license": "UNLICENSED"
 }
--- a/packages/now-build-utils/package.json
+++ b/packages/now-build-utils/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@now/build-utils",
-  "version": "1.3.0",
+  "version": "1.3.2",
  "license": "MIT",
  "main": "./dist/index.js",
  "types": "./dist/index.d.js",
--- a/packages/now-build-utils/src/detect-routes.ts
+++ b/packages/now-build-utils/src/detect-routes.ts
@@ -1,5 +1,5 @@
 import { parse as parsePath } from 'path';
-import { Route, isHandler } from '@now/routing-utils';
+import { Route, Source } from '@now/routing-utils';
 import { Builder } from './types';
 import { getIgnoreApiFilter, sortFiles } from './detect-builders';

@@ -41,20 +41,26 @@ function getSegmentName(segment: string): string | null {
  return null;
 }

-function createRouteFromPath(filePath: string): Route {
+function createRouteFromPath(
+  filePath: string,
+  featHandleMiss: boolean,
+  cleanUrls: boolean
+): { route: Source; isDynamic: boolean } {
  const parts = filePath.split('/');

  let counter = 1;
  const query: string[] = [];
+  let isDynamic = false;

-  const srcParts = parts.map((segment, index): string => {
+  const srcParts = parts.map((segment, i): string => {
    const name = getSegmentName(segment);
-    const isLast = index === parts.length - 1;
+    const isLast = i === parts.length - 1;

    if (name !== null) {
      // We can't use `URLSearchParams` because `$` would get escaped
      query.push(`${name}=$${counter++}`);
-      return `([^\\/]+)`;
+      isDynamic = true;
+      return `([^/]+)`;
    } else if (isLast) {
      const { name: fileName, ext } = parsePath(segment);
      const isIndex = fileName === 'index';
@@ -63,27 +69,43 @@ function createRouteFromPath(filePath: string): Route {
      const names = [
        isIndex ? prefix : `${fileName}\\/`,
        prefix + escapeName(fileName),
-        prefix + escapeName(fileName) + escapeName(ext),
+        featHandleMiss && cleanUrls
+          ? ''
+          : prefix + escapeName(fileName) + escapeName(ext),
      ].filter(Boolean);

      // Either filename with extension, filename without extension
-      // or nothing when the filename is `index`
+      // or nothing when the filename is `index`.
+      // When `cleanUrls: true` then do *not* add the filename with extension.
      return `(${names.join('|')})${isIndex ? '?' : ''}`;
    }

    return segment;
  });

-  const { name: fileName } = parsePath(filePath);
+  const { name: fileName, ext } = parsePath(filePath);
  const isIndex = fileName === 'index';
+  const queryString = `${query.length ? '?' : ''}${query.join('&')}`;

  const src = isIndex
    ? `^/${srcParts.slice(0, -1).join('/')}${srcParts.slice(-1)[0]}$`
    : `^/${srcParts.join('/')}$`;

-  const dest = `/${filePath}${query.length ? '?' : ''}${query.join('&')}`;
-
-  return { src, dest };
+  let route: Source;
+  if (featHandleMiss) {
+    const extensionless = ext ? filePath.slice(0, -ext.length) : filePath;
+    route = {
+      src,
+      dest: `/${extensionless}${queryString}`,
+      check: true,
+    };
+  } else {
+    route = {
+      src,
+      dest: `/${filePath}${queryString}`,
+    };
+  }
+  return { route, isDynamic };
 }

 // Check if the path partially matches and has the same
@@ -193,18 +215,30 @@ function sortFilesBySegmentCount(fileA: string, fileB: string): number {
  return 0;
 }

+interface ApiRoutesResult {
+  defaultRoutes: Source[] | null;
+  dynamicRoutes: Source[] | null;
+  error: { [key: string]: string } | null;
+}
+
 interface RoutesResult {
  defaultRoutes: Route[] | null;
+  redirectRoutes: Route[] | null;
  error: { [key: string]: string } | null;
 }

 async function detectApiRoutes(
  files: string[],
  builders: Builder[],
-  featHandleMiss: boolean
-): Promise<RoutesResult> {
+  featHandleMiss: boolean,
+  cleanUrls: boolean
+): Promise<ApiRoutesResult> {
  if (!files || files.length === 0) {
-    return { defaultRoutes: null, error: null };
+    return {
+      defaultRoutes: null,
+      dynamicRoutes: null,
+      error: null,
+    };
  }

  // The deepest routes need to be
@@ -214,7 +248,8 @@ async function detectApiRoutes(
    .sort(sortFiles)
    .sort(sortFilesBySegmentCount);

-  let defaultRoutes: Route[] = [];
+  const defaultRoutes: Source[] = [];
+  const dynamicRoutes: Source[] = [];

  for (const file of sortedFiles) {
    // We only consider every file in the api directory
@@ -231,6 +266,7 @@ async function detectApiRoutes(
    if (conflictingSegment) {
      return {
        defaultRoutes: null,
+        dynamicRoutes: null,
        error: {
          code: 'conflicting_path_segment',
          message:
@@ -252,6 +288,7 @@ async function detectApiRoutes(

      return {
        defaultRoutes: null,
+        dynamicRoutes: null,
        error: {
          code: 'conflicting_file_path',
          message:
@@ -262,39 +299,14 @@ async function detectApiRoutes(
      };
    }

-    defaultRoutes.push(createRouteFromPath(file));
-  }
-
-  // 404 Route to disable directory listing
-  if (defaultRoutes.length > 0) {
-    if (featHandleMiss) {
-      defaultRoutes = [
-        { handle: 'miss' },
-        {
-          src: '/api/(.+)\\.\\w+',
-          dest: '/api/$1',
-          check: true,
-        },
-        {
-          status: 404,
-          src: '/api(/.*)?$',
-          continue: true,
-        },
-      ];
-    } else if (
-      defaultRoutes.some(
-        route =>
-          !isHandler(route) && route.dest && route.dest.startsWith('/api/')
-      )
-    ) {
-      defaultRoutes.push({
-        status: 404,
-        src: '/api(/.*)?$',
-      });
+    const out = createRouteFromPath(file, featHandleMiss, cleanUrls);
+    if (out.isDynamic) {
+      dynamicRoutes.push(out.route);
    }
+    defaultRoutes.push(out.route);
  }

-  return { defaultRoutes, error: null };
+  return { defaultRoutes, dynamicRoutes, error: null };
 }

 function getPublicBuilder(builders: Builder[]): Builder | null {
@@ -319,17 +331,81 @@ export function detectOutputDirectory(builders: Builder[]): string | null {
 export async function detectRoutes(
  files: string[],
  builders: Builder[],
-  featHandleMiss = false
+  featHandleMiss = false,
+  cleanUrls = false,
+  trailingSlash?: boolean
 ): Promise<RoutesResult> {
-  const routesResult = await detectApiRoutes(files, builders, featHandleMiss);
+  const result = await detectApiRoutes(
+    files,
+    builders,
+    featHandleMiss,
+    cleanUrls
+  );
+  const { dynamicRoutes, defaultRoutes: allRoutes, error } = result;
+  if (error) {
+    return { defaultRoutes: null, redirectRoutes: null, error };
+  }
  const directory = detectOutputDirectory(builders);
+  const defaultRoutes: Route[] = [];
+  const redirectRoutes: Route[] = [];
+  if (allRoutes && allRoutes.length > 0) {
+    const hasApiRoutes = allRoutes.some(
+      r => r.dest && r.dest.startsWith('/api/')
+    );
+    if (featHandleMiss) {
+      defaultRoutes.push({ handle: 'miss' });
+      if (cleanUrls) {
+        const extensions = builders
+          .map(b => parsePath(b.src).ext)
+          .filter(Boolean);
+        if (extensions.length > 0) {
+          const exts = extensions.map(ext => ext.slice(1)).join('|');
+          const group = `(?:\\.(?:${exts}))`;
+          redirectRoutes.push({
+            src: `^/(api(?:.+)?)/index${group}?/?$`,
+            headers: { Location: trailingSlash ? '/$1/' : '/$1' },
+            status: 308,
+          });
+          redirectRoutes.push({
+            src: `^/api/(.+)${group}/?$`,
+            headers: { Location: trailingSlash ? '/api/$1/' : '/api/$1' },
+            status: 308,
+          });
+        }
+      } else {
+        defaultRoutes.push({
+          src: '^/api/(.+)\\.\\w+$',
+          dest: '/api/$1',
+          check: true,
+        });
+      }
+      if (dynamicRoutes) {
+        defaultRoutes.push(...dynamicRoutes);
+      }
+      if (hasApiRoutes) {
+        defaultRoutes.push({
+          src: '^/api(/.*)?$',
+          status: 404,
+          continue: true,
+        });
+      }
+    } else {
+      defaultRoutes.push(...allRoutes);
+      if (hasApiRoutes) {
+        defaultRoutes.push({
+          status: 404,
+          src: '^/api(/.*)?$',
+        });
+      }
+    }
+  }

-  if (routesResult.defaultRoutes && directory && !featHandleMiss) {
-    routesResult.defaultRoutes.push({
+  if (!featHandleMiss && directory) {
+    defaultRoutes.push({
      src: '/(.*)',
      dest: `/${directory}/$1`,
    });
  }

-  return routesResult;
+  return { defaultRoutes, redirectRoutes, error };
 }
--- a/packages/now-build-utils/src/errors.ts
+++ b/packages/now-build-utils/src/errors.ts
@@ -0,0 +1,18 @@
+/**
+ * This error should be thrown from a Builder in
+ * order to stop the build and print a message.
+ * This is necessary to avoid printing a stack trace.
+ */
+export class NowBuildError extends Error {
+  public code: string;
+
+  constructor({ message, code }: Props) {
+    super(message);
+    this.code = code;
+  }
+}
+
+interface Props {
+  message: string;
+  code: string;
+}
--- a/packages/now-build-utils/src/fs/node-version.ts
+++ b/packages/now-build-utils/src/fs/node-version.ts
@@ -1,6 +1,7 @@
 import { intersects } from 'semver';
 import boxen from 'boxen';
 import { NodeVersion } from '../types';
+import { NowBuildError } from '../errors';
 import debug from '../debug';

 const allOptions: NodeVersion[] = [
@@ -14,7 +15,14 @@ const allOptions: NodeVersion[] = [
  },
 ];

-const supportedOptions = allOptions.filter(o => !isDiscontinued(o));
+const pleaseSet =
+  'Please set "engines": { "node": "' +
+  getLatestNodeVersion().range +
+  '" } in your `package.json` file to upgrade to Node.js ' +
+  getLatestNodeVersion().major;
+const upstreamProvider =
+  'This change is the result of a decision made by an upstream infrastructure provider (AWS).' +
+  '\nRead more: https://docs.aws.amazon.com/lambda/latest/dg/runtime-support-policy.html';

 export function getOldestNodeVersion(): NodeVersion {
  return allOptions[allOptions.length - 1];
@@ -26,77 +34,71 @@ export function getLatestNodeVersion(): NodeVersion {

 export async function getSupportedNodeVersion(
  engineRange?: string,
-  silent?: boolean
+  isAuto?: boolean
 ): Promise<NodeVersion> {
  let selection = getOldestNodeVersion();

-  if (!engineRange) {
-    if (!silent) {
-      debug(
-        'Missing `engines` in `package.json`, using default range: ' +
-          selection.range
-      );
-    }
-  } else {
+  if (engineRange) {
    const found = allOptions.some(o => {
      // the array is already in order so return the first
      // match which will be the newest version of node
      selection = o;
      return intersects(o.range, engineRange);
    });
-    const discontinued = isDiscontinued(selection);
-    if (found && !discontinued) {
-      if (!silent) {
-        debug(
-          'Found `engines` in `package.json`, selecting range: ' +
-            selection.range
-        );
-      }
-    } else {
-      throw new Error(
-        'Found `engines` in `package.json` with an unsupported Node.js version range: ' +
-          engineRange +
-          '\nPlease use one of the following supported ranges: ' +
-          JSON.stringify(supportedOptions.map(o => o.range)) +
-          (discontinued
-            ? '\nThis change is the result of a decision made by an upstream infrastructure provider (AWS).' +
-              '\nRead more: https://docs.aws.amazon.com/lambda/latest/dg/runtime-support-policy.html'
-            : '')
-      );
+    if (!found) {
+      const intro =
+        isAuto || !engineRange
+          ? 'This project is using an invalid version of Node.js and must be changed.'
+          : 'Found `engines` in `package.json` with an invalid Node.js version range: ' +
+            engineRange;
+      throw new NowBuildError({
+        code: 'NOW_BUILD_UTILS_NODE_VERSION_INVALID',
+        message: intro + '\n' + pleaseSet,
+      });
    }
  }

-  const { range, discontinueDate } = selection;
-  if (discontinueDate && !isDiscontinued(selection)) {
-    const d = discontinueDate.toISOString().split('T')[0];
-    const validRanges = supportedOptions
-      .filter(o => !o.discontinueDate)
-      .map(o => o.range);
-    const prevTerm = process.env.TERM;
-    if (!prevTerm) {
-      // workaround for https://github.com/sindresorhus/term-size/issues/13
-      process.env.TERM = 'xterm';
-    }
+  if (isDiscontinued(selection)) {
+    const intro =
+      isAuto || !engineRange
+        ? 'This project is using a discontinued version of Node.js and must be upgraded.'
+        : 'Found `engines` in `package.json` with a discontinued Node.js version range: ' +
+          engineRange;
+    throw new NowBuildError({
+      code: 'NOW_BUILD_UTILS_NODE_VERSION_DISCONTINUED',
+      message: intro + '\n' + pleaseSet + '\n' + upstreamProvider,
+    });
+  }
+
+  debug(
+    isAuto || !engineRange
+      ? 'Using default Node.js range: ' + selection.range
+      : (engineRange ? 'Found' : 'Missing') +
+          ' `engines` in `package.json`, selecting range: ' +
+          selection.range
+  );
+
+  if (selection.discontinueDate) {
+    const d = selection.discontinueDate.toISOString().split('T')[0];
    console.warn(
      boxen(
        'NOTICE' +
          '\n' +
-          `\nNode.js version ${range} has reached end-of-life.` +
+          `\nNode.js version ${selection.range} has reached end-of-life.` +
          `\nAs a result, deployments created on or after ${d} will fail to build.` +
-          '\nPlease use one of the following supported `engines` in `package.json`: ' +
-          JSON.stringify(validRanges) +
-          '\nThis change is the result of a decision made by an upstream infrastructure provider (AWS).' +
-          '\nRead more: https://docs.aws.amazon.com/lambda/latest/dg/runtime-support-policy.html',
+          '\n' +
+          pleaseSet +
+          '\n' +
+          upstreamProvider,
        { padding: 1 }
      )
    );
-    process.env.TERM = prevTerm;
  }

  return selection;
 }

 function isDiscontinued({ discontinueDate }: NodeVersion): boolean {
-  const today = new Date();
-  return discontinueDate !== undefined && discontinueDate <= today;
+  const today = Date.now();
+  return discontinueDate !== undefined && discontinueDate.getTime() <= today;
 }
--- a/packages/now-build-utils/src/fs/run-user-scripts.ts
+++ b/packages/now-build-utils/src/fs/run-user-scripts.ts
@@ -7,7 +7,7 @@ import { SpawnOptions } from 'child_process';
 import { deprecate } from 'util';
 import { cpus } from 'os';
 import { Meta, PackageJson, NodeVersion, Config } from '../types';
-import { getSupportedNodeVersion } from './node-version';
+import { getSupportedNodeVersion, getLatestNodeVersion } from './node-version';

 export function spawnAsync(
  command: string,
@@ -140,24 +140,30 @@ export function getSpawnOptions(
 export async function getNodeVersion(
  destPath: string,
  minNodeVersion?: string,
-  config?: Config
+  config?: Config,
+  meta?: Meta
 ): Promise<NodeVersion> {
+  if (meta && meta.isDev) {
+    // Use the system-installed version of `node` in PATH for `now dev`
+    const latest = getLatestNodeVersion();
+    return { ...latest, runtime: 'nodejs' };
+  }
  const { packageJson } = await scanParentDirs(destPath, true);
  let range: string | undefined;
-  let silent = false;
+  let isAuto = false;
  if (packageJson && packageJson.engines && packageJson.engines.node) {
    range = packageJson.engines.node;
  } else if (minNodeVersion) {
    range = minNodeVersion;
-    silent = true;
+    isAuto = true;
  } else if (config && config.nodeVersion) {
    range = config.nodeVersion;
-    silent = true;
+    isAuto = true;
  } else if (config && config.zeroConfig) {
    range = '10.x';
-    silent = true;
+    isAuto = true;
  }
-  return getSupportedNodeVersion(range, silent);
+  return getSupportedNodeVersion(range, isAuto);
 }

 async function scanParentDirs(destPath: string, readPackageJson = false) {
--- a/packages/now-build-utils/src/index.ts
+++ b/packages/now-build-utils/src/index.ts
@@ -66,3 +66,4 @@ export { readConfigFile } from './fs/read-config-file';

 export * from './schemas';
 export * from './types';
+export * from './errors';
--- a/packages/now-build-utils/test/unit.builds-and-routes-detector.test.ts
+++ b/packages/now-build-utils/test/unit.builds-and-routes-detector.test.ts
@@ -1,3 +1,4 @@
+import { Source, Route } from '@now/routing-utils';
 import { detectBuilders, detectRoutes } from '../src';

 describe('Test `detectBuilders`', () => {
@@ -892,7 +893,7 @@ it('Test `detectRoutes`', async () => {
    const { builders } = await detectBuilders(files);
    const { defaultRoutes } = await detectRoutes(files, builders!);
    expect((defaultRoutes![2] as any).status).toBe(404);
-    expect((defaultRoutes![2] as any).src).toBe('/api(/.*)?$');
+    expect((defaultRoutes![2] as any).src).toBe('^/api(/.*)?$');
    expect((defaultRoutes![3] as any).src).toBe('/(.*)');
    expect((defaultRoutes![3] as any).dest).toBe('/public/$1');
    expect(defaultRoutes!.length).toBe(4);
@@ -908,7 +909,7 @@ it('Test `detectRoutes`', async () => {
    const { builders } = await detectBuilders(files, pkg);
    const { defaultRoutes } = await detectRoutes(files, builders!);
    expect((defaultRoutes![1] as any).status).toBe(404);
-    expect((defaultRoutes![1] as any).src).toBe('/api(/.*)?$');
+    expect((defaultRoutes![1] as any).src).toBe('^/api(/.*)?$');
    expect(defaultRoutes!.length).toBe(2);
  }

@@ -946,7 +947,7 @@ it('Test `detectRoutes`', async () => {

    expect(defaultRoutes!.length).toBe(3);
    expect((defaultRoutes![0] as any).src).toBe(
-      '^/api/([^\\/]+)(\\/|\\/index|\\/index\\.js)?$'
+      '^/api/([^/]+)(\\/|\\/index|\\/index\\.js)?$'
    );
    expect((defaultRoutes![0] as any).dest).toBe(
      '/api/[date]/index.js?date=$1'
@@ -993,20 +994,6 @@ it('Test `detectRoutes`', async () => {
 it('Test `detectRoutes` with `featHandleMiss=true`', async () => {
  const featHandleMiss = true;

-  const expectedRoutes = [
-    { handle: 'miss' },
-    {
-      src: '/api/(.+)\\.\\w+',
-      dest: '/api/$1',
-      check: true,
-    },
-    {
-      status: 404,
-      src: '/api(/.*)?$',
-      continue: true,
-    },
-  ];
-
  {
    const files = ['api/user.go', 'api/team.js', 'api/package.json'];

@@ -1016,7 +1003,19 @@ it('Test `detectRoutes` with `featHandleMiss=true`', async () => {
      builders!,
      featHandleMiss
    );
-    expect(defaultRoutes).toStrictEqual(expectedRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      {
+        src: '^/api/(.+)\\.\\w+$',
+        dest: '/api/$1',
+        check: true,
+      },
+      {
+        status: 404,
+        src: '^/api(/.*)?$',
+        continue: true,
+      },
+    ]);
  }

  {
@@ -1065,7 +1064,29 @@ it('Test `detectRoutes` with `featHandleMiss=true`', async () => {
      builders!,
      featHandleMiss
    );
-    expect(defaultRoutes).toStrictEqual(expectedRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      {
+        src: '^/api/(.+)\\.\\w+$',
+        dest: '/api/$1',
+        check: true,
+      },
+      {
+        src: '^/api/([^/]+)/([^/]+)$',
+        dest: '/api/[endpoint]/[id]?endpoint=$1&id=$2',
+        check: true,
+      },
+      {
+        src: '^/api/([^/]+)$',
+        dest: '/api/[endpoint]?endpoint=$1',
+        check: true,
+      },
+      {
+        status: 404,
+        src: '^/api(/.*)?$',
+        continue: true,
+      },
+    ]);
  }

  {
@@ -1081,7 +1102,29 @@ it('Test `detectRoutes` with `featHandleMiss=true`', async () => {
      builders!,
      featHandleMiss
    );
-    expect(defaultRoutes).toStrictEqual(expectedRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      {
+        src: '^/api/(.+)\\.\\w+$',
+        dest: '/api/$1',
+        check: true,
+      },
+      {
+        src: '^/api/([^/]+)/([^/]+)$',
+        dest: '/api/[endpoint]/[id]?endpoint=$1&id=$2',
+        check: true,
+      },
+      {
+        src: '^/api/([^/]+)$',
+        dest: '/api/[endpoint]?endpoint=$1',
+        check: true,
+      },
+      {
+        status: 404,
+        src: '^/api(/.*)?$',
+        continue: true,
+      },
+    ]);
  }

  {
@@ -1103,7 +1146,24 @@ it('Test `detectRoutes` with `featHandleMiss=true`', async () => {
      builders!,
      featHandleMiss
    );
-    expect(defaultRoutes).toStrictEqual(expectedRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      {
+        src: '^/api/(.+)\\.\\w+$',
+        dest: '/api/$1',
+        check: true,
+      },
+      {
+        src: '^/api/([^/]+)$',
+        dest: '/api/[endpoint]?endpoint=$1',
+        check: true,
+      },
+      {
+        status: 404,
+        src: '^/api(/.*)?$',
+        continue: true,
+      },
+    ]);
  }

  {
@@ -1127,7 +1187,19 @@ it('Test `detectRoutes` with `featHandleMiss=true`', async () => {
      builders!,
      featHandleMiss
    );
-    expect(defaultRoutes).toStrictEqual(expectedRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      {
+        src: '^/api/(.+)\\.\\w+$',
+        dest: '/api/$1',
+        check: true,
+      },
+      {
+        status: 404,
+        src: '^/api(/.*)?$',
+        continue: true,
+      },
+    ]);
  }

  {
@@ -1139,7 +1211,24 @@ it('Test `detectRoutes` with `featHandleMiss=true`', async () => {
      builders!,
      featHandleMiss
    );
-    expect(defaultRoutes).toStrictEqual(expectedRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      {
+        src: '^/api/(.+)\\.\\w+$',
+        dest: '/api/$1',
+        check: true,
+      },
+      {
+        src: '^/api/([^/]+)(\\/|\\/index|\\/index\\.js)?$',
+        dest: '/api/[date]/index?date=$1',
+        check: true,
+      },
+      {
+        status: 404,
+        src: '^/api(/.*)?$',
+        continue: true,
+      },
+    ]);
  }

  {
@@ -1157,7 +1246,16 @@ it('Test `detectRoutes` with `featHandleMiss=true`', async () => {
      builders!,
      featHandleMiss
    );
-    expect(defaultRoutes).toStrictEqual(expectedRoutes);
+
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      {
+        src: '^/api/(.+)\\.\\w+$',
+        dest: '/api/$1',
+        check: true,
+      },
+      { status: 404, src: '^/api(/.*)?$', continue: true },
+    ]);
  }

  {
@@ -1171,6 +1269,611 @@ it('Test `detectRoutes` with `featHandleMiss=true`', async () => {
      builders!,
      featHandleMiss
    );
-    expect(defaultRoutes).toStrictEqual(expectedRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      {
+        src: '^/api/(.+)\\.\\w+$',
+        dest: '/api/$1',
+        check: true,
+      },
+      { status: 404, src: '^/api(/.*)?$', continue: true },
+    ]);
  }
 });
+
+it('Test `detectRoutes` with `featHandleMiss=true`, `cleanUrls=true`', async () => {
+  const featHandleMiss = true;
+  const cleanUrls = true;
+  const testHeaders = (redirectRoutes: Route[] | null) => {
+    if (!redirectRoutes || redirectRoutes.length === 0) {
+      throw new Error('Expected one redirect but found none');
+    }
+    expect(redirectRoutes).toBeDefined();
+    expect(redirectRoutes.length).toBe(2);
+  };
+
+  {
+    const files = ['api/user.go', 'api/team.js', 'api/package.json'];
+
+    const { builders } = await detectBuilders(files);
+    const { defaultRoutes, redirectRoutes } = await detectRoutes(
+      files,
+      builders!,
+      featHandleMiss,
+      cleanUrls
+    );
+    testHeaders(redirectRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      {
+        status: 404,
+        src: '^/api(/.*)?$',
+        continue: true,
+      },
+    ]);
+
+    // expected redirect should match inputs
+    const getLocation = createReplaceLocation(redirectRoutes);
+
+    expect(getLocation('/api/index')).toBe('/api');
+    expect(getLocation('/api/index.js')).toBe('/api');
+    expect(getLocation('/api/user.js')).toBe('/api/user');
+    expect(getLocation('/api/user.prod.js')).toBe('/api/user.prod');
+    expect(getLocation('/api/user/index.js')).toBe('/api/user');
+
+    expect(getLocation('/api/index.go')).toBe('/api');
+    expect(getLocation('/api/user.go')).toBe('/api/user');
+    expect(getLocation('/api/user.prod.go')).toBe('/api/user.prod');
+    expect(getLocation('/api/user/index.go')).toBe('/api/user');
+
+    expect(getLocation('/api/index.cpp')).toBe(null);
+    expect(getLocation('/api/user.cpp')).toBe(null);
+    expect(getLocation('/api/user.prod.cpp')).toBe(null);
+    expect(getLocation('/api/user/index.cpp')).toBe(null);
+
+    expect(getLocation('/api/user')).toBe(null);
+    expect(getLocation('/api/user/get')).toBe(null);
+    expect(getLocation('/apiindex')).toBe(null);
+    expect(getLocation('/api-index')).toBe(null);
+    expect(getLocation('/apiuserindex')).toBe(null);
+    expect(getLocation('/apiuser-index')).toBe(null);
+  }
+
+  {
+    const files = ['api/user.go', 'api/user.js'];
+
+    const { builders } = await detectBuilders(files);
+    const { error } = await detectRoutes(
+      files,
+      builders!,
+      featHandleMiss,
+      cleanUrls
+    );
+    expect(error!.code).toBe('conflicting_file_path');
+  }
+
+  {
+    const files = ['api/[user].go', 'api/[team]/[id].js'];
+
+    const { builders } = await detectBuilders(files);
+    const { error } = await detectRoutes(
+      files,
+      builders!,
+      featHandleMiss,
+      cleanUrls
+    );
+    expect(error!.code).toBe('conflicting_file_path');
+  }
+
+  {
+    const files = ['api/[team]/[team].js'];
+
+    const { builders } = await detectBuilders(files);
+    const { error } = await detectRoutes(
+      files,
+      builders!,
+      featHandleMiss,
+      cleanUrls
+    );
+    expect(error!.code).toBe('conflicting_path_segment');
+  }
+
+  {
+    const files = ['api/date/index.js', 'api/date/index.go'];
+
+    const { builders } = await detectBuilders(files);
+    const { defaultRoutes, error } = await detectRoutes(
+      files,
+      builders!,
+      featHandleMiss,
+      cleanUrls
+    );
+    expect(defaultRoutes).toBe(null);
+    expect(error!.code).toBe('conflicting_file_path');
+  }
+
+  {
+    const files = ['api/[endpoint].js', 'api/[endpoint]/[id].js'];
+
+    const { builders } = await detectBuilders(files);
+    const { defaultRoutes, redirectRoutes } = await detectRoutes(
+      files,
+      builders!,
+      featHandleMiss,
+      cleanUrls
+    );
+    testHeaders(redirectRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      {
+        src: '^/api/([^/]+)/([^/]+)$',
+        dest: '/api/[endpoint]/[id]?endpoint=$1&id=$2',
+        check: true,
+      },
+      {
+        src: '^/api/([^/]+)$',
+        dest: '/api/[endpoint]?endpoint=$1',
+        check: true,
+      },
+      {
+        status: 404,
+        src: '^/api(/.*)?$',
+        continue: true,
+      },
+    ]);
+  }
+
+  {
+    const files = [
+      'public/index.html',
+      'api/[endpoint].js',
+      'api/[endpoint]/[id].js',
+    ];
+
+    const { builders } = await detectBuilders(files);
+    const { defaultRoutes, redirectRoutes } = await detectRoutes(
+      files,
+      builders!,
+      featHandleMiss,
+      cleanUrls
+    );
+    testHeaders(redirectRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      {
+        src: '^/api/([^/]+)/([^/]+)$',
+        dest: '/api/[endpoint]/[id]?endpoint=$1&id=$2',
+        check: true,
+      },
+      {
+        src: '^/api/([^/]+)$',
+        dest: '/api/[endpoint]?endpoint=$1',
+        check: true,
+      },
+      {
+        status: 404,
+        src: '^/api(/.*)?$',
+        continue: true,
+      },
+    ]);
+  }
+
+  {
+    const pkg = {
+      scripts: {
+        build: 'next build',
+      },
+      framework: {
+        slug: 'next',
+        version: '9.0.0',
+      },
+    };
+
+    const files = ['public/index.html', 'api/[endpoint].js'];
+
+    const { builders } = await detectBuilders(files, pkg);
+    const { defaultRoutes, redirectRoutes } = await detectRoutes(
+      files,
+      builders!,
+      featHandleMiss,
+      cleanUrls
+    );
+    testHeaders(redirectRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      {
+        src: '^/api/([^/]+)$',
+        dest: '/api/[endpoint]?endpoint=$1',
+        check: true,
+      },
+      {
+        status: 404,
+        src: '^/api(/.*)?$',
+        continue: true,
+      },
+    ]);
+  }
+
+  {
+    const files = ['public/index.html'];
+
+    const { builders } = await detectBuilders(files);
+    const { defaultRoutes } = await detectRoutes(
+      files,
+      builders!,
+      featHandleMiss,
+      cleanUrls
+    );
+    expect(defaultRoutes).toStrictEqual([]);
+  }
+
+  {
+    const files = ['api/date/index.js', 'api/date.js'];
+
+    const { builders } = await detectBuilders(files);
+    const { defaultRoutes, redirectRoutes } = await detectRoutes(
+      files,
+      builders!,
+      featHandleMiss,
+      cleanUrls
+    );
+    testHeaders(redirectRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      {
+        status: 404,
+        src: '^/api(/.*)?$',
+        continue: true,
+      },
+    ]);
+  }
+
+  {
+    const files = ['api/date.js', 'api/[date]/index.js'];
+
+    const { builders } = await detectBuilders(files);
+    const { defaultRoutes, redirectRoutes } = await detectRoutes(
+      files,
+      builders!,
+      featHandleMiss,
+      cleanUrls
+    );
+    testHeaders(redirectRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      {
+        src: '^/api/([^/]+)(\\/|\\/index)?$',
+        dest: '/api/[date]/index?date=$1',
+        check: true,
+      },
+      {
+        status: 404,
+        src: '^/api(/.*)?$',
+        continue: true,
+      },
+    ]);
+  }
+
+  {
+    const files = [
+      'api/index.ts',
+      'api/index.d.ts',
+      'api/users/index.ts',
+      'api/users/index.d.ts',
+      'api/food.ts',
+      'api/ts/gold.ts',
+    ];
+    const { builders } = await detectBuilders(files);
+    const { defaultRoutes, redirectRoutes } = await detectRoutes(
+      files,
+      builders!,
+      featHandleMiss,
+      cleanUrls
+    );
+    testHeaders(redirectRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      { status: 404, src: '^/api(/.*)?$', continue: true },
+    ]);
+  }
+
+  {
+    // use a custom runtime
+    const functions = { 'api/user.php': { runtime: 'now-php@0.0.5' } };
+    const files = ['api/user.php'];
+
+    const { builders } = await detectBuilders(files, null, { functions });
+    const { defaultRoutes, redirectRoutes } = await detectRoutes(
+      files,
+      builders!,
+      featHandleMiss,
+      cleanUrls
+    );
+    testHeaders(redirectRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      { status: 404, src: '^/api(/.*)?$', continue: true },
+    ]);
+  }
+});
+
+it('Test `detectRoutes` with `featHandleMiss=true`, `cleanUrls=true`, `trailingSlash=true`', async () => {
+  const featHandleMiss = true;
+  const cleanUrls = true;
+  const trailingSlash = true;
+  const testHeaders = (redirectRoutes: Route[] | null) => {
+    if (!redirectRoutes || redirectRoutes.length === 0) {
+      throw new Error('Expected one redirect but found none');
+    }
+    expect(redirectRoutes).toBeDefined();
+    expect(redirectRoutes.length).toBe(2);
+  };
+
+  {
+    const files = ['api/user.go', 'api/team.js', 'api/package.json'];
+
+    const { builders } = await detectBuilders(files);
+    const { defaultRoutes, redirectRoutes } = await detectRoutes(
+      files,
+      builders!,
+      featHandleMiss,
+      cleanUrls,
+      trailingSlash
+    );
+    testHeaders(redirectRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      {
+        status: 404,
+        src: '^/api(/.*)?$',
+        continue: true,
+      },
+    ]);
+
+    // expected redirect should match inputs
+    const getLocation = createReplaceLocation(redirectRoutes);
+
+    expect(getLocation('/api/index')).toBe('/api/');
+    expect(getLocation('/api/index.js')).toBe('/api/');
+    expect(getLocation('/api/user.js')).toBe('/api/user/');
+    expect(getLocation('/api/user.prod.js')).toBe('/api/user.prod/');
+    expect(getLocation('/api/user/index.js')).toBe('/api/user/');
+
+    expect(getLocation('/api/index.go')).toBe('/api/');
+    expect(getLocation('/api/user.go')).toBe('/api/user/');
+    expect(getLocation('/api/user.prod.go')).toBe('/api/user.prod/');
+    expect(getLocation('/api/user/index.go')).toBe('/api/user/');
+
+    expect(getLocation('/api/index.cpp')).toBe(null);
+    expect(getLocation('/api/user.cpp')).toBe(null);
+    expect(getLocation('/api/user.prod.cpp')).toBe(null);
+    expect(getLocation('/api/user/index.cpp')).toBe(null);
+
+    expect(getLocation('/api/user')).toBe(null);
+    expect(getLocation('/api/user/get')).toBe(null);
+    expect(getLocation('/apiindex')).toBe(null);
+    expect(getLocation('/api.index')).toBe(null);
+    expect(getLocation('/api.index.js')).toBe(null);
+    expect(getLocation('/api-index')).toBe(null);
+    expect(getLocation('/apiuser.index')).toBe(null);
+    expect(getLocation('/apiuser-index')).toBe(null);
+    expect(getLocation('/apiuser-index')).toBe(null);
+  }
+
+  {
+    const files = ['api/[endpoint].js', 'api/[endpoint]/[id].js'];
+
+    const { builders } = await detectBuilders(files);
+    const { defaultRoutes, redirectRoutes } = await detectRoutes(
+      files,
+      builders!,
+      featHandleMiss,
+      cleanUrls,
+      trailingSlash
+    );
+    testHeaders(redirectRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      {
+        src: '^/api/([^/]+)/([^/]+)$',
+        dest: '/api/[endpoint]/[id]?endpoint=$1&id=$2',
+        check: true,
+      },
+      {
+        src: '^/api/([^/]+)$',
+        dest: '/api/[endpoint]?endpoint=$1',
+        check: true,
+      },
+      {
+        status: 404,
+        src: '^/api(/.*)?$',
+        continue: true,
+      },
+    ]);
+  }
+
+  {
+    const files = [
+      'public/index.html',
+      'api/[endpoint].js',
+      'api/[endpoint]/[id].js',
+    ];
+
+    const { builders } = await detectBuilders(files);
+    const { defaultRoutes, redirectRoutes } = await detectRoutes(
+      files,
+      builders!,
+      featHandleMiss,
+      cleanUrls,
+      trailingSlash
+    );
+    testHeaders(redirectRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      {
+        src: '^/api/([^/]+)/([^/]+)$',
+        dest: '/api/[endpoint]/[id]?endpoint=$1&id=$2',
+        check: true,
+      },
+      {
+        src: '^/api/([^/]+)$',
+        dest: '/api/[endpoint]?endpoint=$1',
+        check: true,
+      },
+      {
+        status: 404,
+        src: '^/api(/.*)?$',
+        continue: true,
+      },
+    ]);
+  }
+
+  {
+    const pkg = {
+      scripts: {
+        build: 'next build',
+      },
+      framework: {
+        slug: 'next',
+        version: '9.0.0',
+      },
+    };
+
+    const files = ['public/index.html', 'api/[endpoint].js'];
+
+    const { builders } = await detectBuilders(files, pkg);
+    const { defaultRoutes, redirectRoutes } = await detectRoutes(
+      files,
+      builders!,
+      featHandleMiss,
+      cleanUrls,
+      trailingSlash
+    );
+    testHeaders(redirectRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      {
+        src: '^/api/([^/]+)$',
+        dest: '/api/[endpoint]?endpoint=$1',
+        check: true,
+      },
+      {
+        status: 404,
+        src: '^/api(/.*)?$',
+        continue: true,
+      },
+    ]);
+  }
+
+  {
+    const files = ['api/date/index.js', 'api/date.js'];
+
+    const { builders } = await detectBuilders(files);
+    const { defaultRoutes, redirectRoutes } = await detectRoutes(
+      files,
+      builders!,
+      featHandleMiss,
+      cleanUrls,
+      trailingSlash
+    );
+    testHeaders(redirectRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      {
+        status: 404,
+        src: '^/api(/.*)?$',
+        continue: true,
+      },
+    ]);
+  }
+
+  {
+    const files = ['api/date.js', 'api/[date]/index.js'];
+
+    const { builders } = await detectBuilders(files);
+    const { defaultRoutes, redirectRoutes } = await detectRoutes(
+      files,
+      builders!,
+      featHandleMiss,
+      cleanUrls,
+      trailingSlash
+    );
+    testHeaders(redirectRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      {
+        src: '^/api/([^/]+)(\\/|\\/index)?$',
+        dest: '/api/[date]/index?date=$1',
+        check: true,
+      },
+      {
+        status: 404,
+        src: '^/api(/.*)?$',
+        continue: true,
+      },
+    ]);
+  }
+
+  {
+    const files = [
+      'api/index.ts',
+      'api/index.d.ts',
+      'api/users/index.ts',
+      'api/users/index.d.ts',
+      'api/food.ts',
+      'api/ts/gold.ts',
+    ];
+    const { builders } = await detectBuilders(files);
+    const { defaultRoutes, redirectRoutes } = await detectRoutes(
+      files,
+      builders!,
+      featHandleMiss,
+      cleanUrls,
+      trailingSlash
+    );
+    testHeaders(redirectRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      { status: 404, src: '^/api(/.*)?$', continue: true },
+    ]);
+  }
+
+  {
+    // use a custom runtime
+    const functions = { 'api/user.php': { runtime: 'now-php@0.0.5' } };
+    const files = ['api/user.php'];
+
+    const { builders } = await detectBuilders(files, null, { functions });
+    const { defaultRoutes, redirectRoutes } = await detectRoutes(
+      files,
+      builders!,
+      featHandleMiss,
+      cleanUrls,
+      trailingSlash
+    );
+    testHeaders(redirectRoutes);
+    expect(defaultRoutes).toStrictEqual([
+      { handle: 'miss' },
+      { status: 404, src: '^/api(/.*)?$', continue: true },
+    ]);
+  }
+});
+
+/**
+ * Create a function that will replace matched redirects
+ * similar to how it works with `now-proxy` in production.
+ */
+function createReplaceLocation(redirectRoutes: Route[] | null) {
+  const redirectSources = (redirectRoutes || []) as Source[];
+  return (filePath: string): string | null => {
+    for (const r of redirectSources) {
+      const m = new RegExp(r.src).exec(filePath);
+      console.log({ filePath, r, m });
+      if (m && r.headers) {
+        const match = m[1] || '';
+        return r.headers['Location'].replace('$1', match);
+      }
+    }
+    return null;
+  };
+}
--- a/packages/now-build-utils/test/unit.test.js
+++ b/packages/now-build-utils/test/unit.test.js
@@ -47,12 +47,31 @@ it('should create zip files with symlinks properly', async () => {
 });

 it('should only match supported node versions', async () => {
-  expect(await getSupportedNodeVersion('10.x')).toHaveProperty('major', 10);
-  expect(await getSupportedNodeVersion('12.x')).toHaveProperty('major', 12);
-  expect(getSupportedNodeVersion('8.11.x')).rejects.toThrow();
-  expect(getSupportedNodeVersion('6.x')).rejects.toThrow();
-  expect(getSupportedNodeVersion('999.x')).rejects.toThrow();
-  expect(getSupportedNodeVersion('foo')).rejects.toThrow();
+  expect(await getSupportedNodeVersion('10.x', false)).toHaveProperty(
+    'major',
+    10
+  );
+  expect(await getSupportedNodeVersion('12.x', false)).toHaveProperty(
+    'major',
+    12
+  );
+  expect(getSupportedNodeVersion('8.11.x', false)).rejects.toThrow();
+  expect(getSupportedNodeVersion('6.x', false)).rejects.toThrow();
+  expect(getSupportedNodeVersion('999.x', false)).rejects.toThrow();
+  expect(getSupportedNodeVersion('foo', false)).rejects.toThrow();
+
+  expect(await getSupportedNodeVersion('10.x', true)).toHaveProperty(
+    'major',
+    10
+  );
+  expect(await getSupportedNodeVersion('12.x', true)).toHaveProperty(
+    'major',
+    12
+  );
+  expect(getSupportedNodeVersion('8.11.x', true)).rejects.toThrow();
+  expect(getSupportedNodeVersion('6.x', true)).rejects.toThrow();
+  expect(getSupportedNodeVersion('999.x', true)).rejects.toThrow();
+  expect(getSupportedNodeVersion('foo', true)).rejects.toThrow();
 });

 it('should match all semver ranges', async () => {
@@ -85,10 +104,35 @@ it('should select correct node version in getNodeVersion()', async () => {
  ).toHaveProperty('major', 10);
 });

+it('should ignore node version in now dev getNodeVersion()', async () => {
+  expect(
+    await getNodeVersion(
+      '/tmp',
+      undefined,
+      { nodeVersion: '1' },
+      { isDev: true }
+    )
+  ).toHaveProperty('runtime', 'nodejs');
+});
+
 it('should get latest node version', async () => {
  expect(await getLatestNodeVersion()).toHaveProperty('major', 12);
 });

+it('should throw for discontinued versions', async () => {
+  // Mock a future date so that Node 8 becomes discontinued
+  const realDateNow = Date.now.bind(global.Date);
+  global.Date.now = () => new Date('2020-02-14').getTime();
+
+  expect(getSupportedNodeVersion('', false)).rejects.toThrow();
+  expect(getSupportedNodeVersion('8.10.x', false)).rejects.toThrow();
+
+  expect(getSupportedNodeVersion('', true)).rejects.toThrow();
+  expect(getSupportedNodeVersion('8.10.x', true)).rejects.toThrow();
+
+  global.Date.now = realDateNow;
+});
+
 it('should support require by path for legacy builders', () => {
  const index = require('@now/build-utils');

--- a/packages/now-cli/README.md
+++ b/packages/now-cli/README.md
@@ -6,7 +6,7 @@

 To install the latest version of Now CLI, visit [zeit.co/download](https://zeit.co/download) or run this command:

-```bash
+```sh
 npm i -g now
 ```

--- a/packages/now-cli/package.json
+++ b/packages/now-cli/package.json
@@ -1,6 +1,6 @@
 {
  "name": "now",
-  "version": "16.7.1",
+  "version": "16.7.2-canary.3",
  "preferGlobal": true,
  "license": "Apache-2.0",
  "description": "The command-line interface for Now",
--- a/packages/now-cli/src/commands/dev/dev.ts
+++ b/packages/now-cli/src/commands/dev/dev.ts
@@ -17,9 +17,7 @@ export default async function dev(
  args: string[],
  output: Output
 ) {
-  output.dim(
-    `Now CLI ${pkg.version} dev (beta) — https://zeit.co/feedback`
-  );
+  output.dim(`Now CLI ${pkg.version} dev (beta) — https://zeit.co/feedback`);

  const [dir = '.'] = args;
  const cwd = path.resolve(dir);
--- a/packages/now-cli/src/commands/scale.js
+++ b/packages/now-cli/src/commands/scale.js
@@ -18,7 +18,10 @@ import getMinFromArgs from '../util/scale/get-min-from-args';
 import patchDeploymentScale from '../util/scale/patch-deployment-scale';
 import waitVerifyDeploymentScale from '../util/scale/wait-verify-deployment-scale';
 import { handleError } from '../util/error';
-import { VerifyScaleTimeout, DeploymentTypeUnsupported } from '../util/errors-ts';
+import {
+  VerifyScaleTimeout,
+  DeploymentTypeUnsupported,
+} from '../util/errors-ts';
 import {
  DeploymentNotFound,
  DeploymentPermissionDenied,
@@ -28,7 +31,7 @@ import {
  InvalidMaxForScale,
  InvalidMinForScale,
  InvalidScaleMinMaxRelation,
-  NotSupportedMinScaleSlots
+  NotSupportedMinScaleSlots,
 } from '../util/errors-ts';
 import { InvalidAllForScale, InvalidRegionOrDCForScale } from '../util/errors';
 import handleCertError from '../util/certs/handle-cert-error';
@@ -56,7 +59,9 @@ const help = () => {

  ${chalk.dim('Examples:')}

-  ${chalk.gray('–')} Enable your deployment in all datacenters (min: 0, max: auto)
+  ${chalk.gray(
+    '–'
+  )} Enable your deployment in all datacenters (min: 0, max: auto)

    ${chalk.cyan('$ now scale my-deployment-123.now.sh all')}

@@ -87,7 +92,7 @@ export default async function main(ctx) {
    argv = getArgs(ctx.argv.slice(2), {
      '--verify-timeout': Number,
      '--no-verify': Boolean,
-      '-n': '--no-verify'
+      '-n': '--no-verify',
    });
  } catch (err) {
    handleError(err);
@@ -100,7 +105,10 @@ export default async function main(ctx) {
  }

  // Prepare the context
-  const { authConfig: { token }, config } = ctx;
+  const {
+    authConfig: { token },
+    config,
+  } = ctx;
  const { currentTeam } = config;
  const { apiUrl } = ctx;
  const debug = argv['--debug'];
@@ -155,8 +163,7 @@ export default async function main(ctx) {
  }
  if (dcs instanceof InvalidRegionOrDCForScale) {
    output.error(
-      `The value "${dcs.meta
-        .regionOrDC}" is not a valid region or DC identifier`
+      `The value "${dcs.meta.regionOrDC}" is not a valid region or DC identifier`
    );
    now.close();
    return 1;
@@ -165,8 +172,7 @@ export default async function main(ctx) {
  const min = getMinFromArgs(argv._);
  if (min instanceof InvalidMinForScale) {
    output.error(
-      `Invalid <min> parameter "${min.meta
-        .value}". A number or "auto" were expected`
+      `Invalid <min> parameter "${min.meta.value}". A number or "auto" were expected`
    );
    now.close();
    return 1;
@@ -175,24 +181,21 @@ export default async function main(ctx) {
  const max = getMaxFromArgs(argv._);
  if (max instanceof InvalidMinForScale) {
    output.error(
-      `Invalid <min> parameter "${max.meta
-        .value}". A number or "auto" were expected`
+      `Invalid <min> parameter "${max.meta.value}". A number or "auto" were expected`
    );
    now.close();
    return 1;
  }
  if (max instanceof InvalidArgsForMinMaxScale) {
    output.error(
-      `Invalid number of arguments: expected <min> ("${max.meta
-        .min}") and [max]`
+      `Invalid number of arguments: expected <min> ("${max.meta.min}") and [max]`
    );
    now.close();
    return 1;
  }
  if (max instanceof InvalidMaxForScale) {
    output.error(
-      `Invalid <max> parameter "${max.meta
-        .value}". A number or "auto" were expected`
+      `Invalid <max> parameter "${max.meta.value}". A number or "auto" were expected`
    );
    now.close();
    return 1;
@@ -262,14 +265,15 @@ export default async function main(ctx) {
    deployment.url
  );
  if (result instanceof ForbiddenScaleMinInstances) {
-    output.error(`You can't scale to more than ${result.meta.max} min instances with your current plan.`);
+    output.error(
+      `You can't scale to more than ${result.meta.max} min instances with your current plan.`
+    );
    now.close();
    return 1;
  }
  if (result instanceof ForbiddenScaleMaxInstances) {
    output.error(
-      `You can't scale to more than ${result.meta
-        .max} max instances with your current plan.`
+      `You can't scale to more than ${result.meta.max} max instances with your current plan.`
    );
    now.close();
    return 1;
--- a/packages/now-cli/src/util/deploy/process-deployment.ts
+++ b/packages/now-cli/src/util/deploy/process-deployment.ts
@@ -82,16 +82,6 @@ export default async function processDeployment({
          `Total files ${event.payload.total.size}, ${event.payload.missing.length} changed`
        );

-        if (!quiet) {
-          log(
-            `Synced ${pluralize(
-              'file',
-              event.payload.missing.length,
-              true
-            )} ${uploadStamp()}`
-          );
-        }
-
        const missingSize = event.payload.missing
          .map((sha: string) => event.payload.total.get(sha).data.length)
          .reduce((a: number, b: number) => a + b, 0);
@@ -121,6 +111,13 @@ export default async function processDeployment({
        now._host = event.payload.url;

        if (!quiet) {
+          log(
+            `Synced ${pluralize(
+              'file',
+              event.payload.missing.length,
+              true
+            )} ${uploadStamp()}`
+          );
          const version = isLegacy ? `${chalk.grey('[v1]')} ` : '';
          log(`https://${event.payload.url} ${version}${deployStamp()}`);
        } else {
@@ -128,7 +125,10 @@ export default async function processDeployment({
        }

        if (queuedSpinner === null) {
-          queuedSpinner = wait('Queued...');
+          queuedSpinner =
+            event.payload.readyState === 'QUEUED'
+              ? wait('Queued...')
+              : wait('Building...');
        }
      }

@@ -200,15 +200,6 @@ export default async function processDeployment({
        debug(
          `Total files ${event.payload.total.size}, ${event.payload.missing.length} changed`
        );
-        if (!quiet) {
-          log(
-            `Synced ${pluralize(
-              'file',
-              event.payload.missing.length,
-              true
-            )} ${uploadStamp()}`
-          );
-        }

        const missingSize = event.payload.missing
          .map((sha: string) => event.payload.total.get(sha).data.length)
@@ -239,6 +230,13 @@ export default async function processDeployment({
        now._host = event.payload.url;

        if (!quiet) {
+          log(
+            `Synced ${pluralize(
+              'file',
+              event.payload.missing.length,
+              true
+            )} ${uploadStamp()}`
+          );
          const version = isLegacy ? `${chalk.grey('[v1]')} ` : '';
          log(`${event.payload.url} ${version}${deployStamp()}`);
        } else {
--- a/packages/now-cli/src/util/dev/server.ts
+++ b/packages/now-cli/src/util/dev/server.ts
@@ -544,10 +544,11 @@ export default class DevServer {
      }

      if (builders) {
-        const { defaultRoutes, error: routesError } = await detectRoutes(
-          files,
-          builders
-        );
+        const {
+          defaultRoutes,
+          redirectRoutes,
+          error: routesError,
+        } = await detectRoutes(files, builders);

        config.builds = config.builds || [];
        config.builds.push(...builders);
@@ -556,8 +557,12 @@ export default class DevServer {
          this.output.error(routesError.message);
          await this.exit();
        } else {
-          config.routes = config.routes || [];
-          config.routes.push(...(defaultRoutes as RouteConfig[]));
+          const routes: RouteConfig[] = [];
+          const { routes: nowConfigRoutes } = config;
+          routes.push(...(redirectRoutes || []));
+          routes.push(...(nowConfigRoutes || []));
+          routes.push(...(defaultRoutes || []));
+          config.routes = routes;
        }
      }
    }
--- a/packages/now-cli/src/util/ignored.ts
+++ b/packages/now-cli/src/util/ignored.ts
@@ -15,7 +15,7 @@ export default `.hg
 .wafpicke-*
 .lock-wscript
 .env
-.env.build
+.env.*
 .venv
 npm-debug.log
 config.gypi
--- a/packages/now-client/package.json
+++ b/packages/now-client/package.json
@@ -1,6 +1,6 @@
 {
  "name": "now-client",
-  "version": "6.0.1",
+  "version": "6.0.2-canary.0",
  "main": "dist/index.js",
  "typings": "dist/index.d.ts",
  "homepage": "https://zeit.co",
@@ -38,7 +38,7 @@
    ]
  },
  "dependencies": {
-    "@zeit/fetch": "5.1.0",
+    "@zeit/fetch": "5.2.0",
    "async-retry": "1.2.3",
    "async-sema": "3.0.0",
    "fs-extra": "8.0.1",
--- a/packages/now-client/src/upload.ts
+++ b/packages/now-client/src/upload.ts
@@ -115,7 +115,8 @@ export async function* upload(
              apiUrl,
              userAgent,
            },
-            clientOptions.debug
+            clientOptions.debug,
+            true
          );

          if (res.status === 200) {
@@ -168,8 +169,9 @@ export async function* upload(
        return result;
      },
      {
-        retries: 3,
-        factor: 2,
+        retries: 5,
+        factor: 6,
+        minTimeout: 10,
      }
    );
  });
--- a/packages/now-client/src/utils/fetch.ts
+++ b/packages/now-client/src/utils/fetch.ts
@@ -0,0 +1,6 @@
+import nodeFetch from 'node-fetch';
+import setupZeitFetch from '@zeit/fetch';
+
+const zeitFetch = setupZeitFetch(nodeFetch);
+
+export { zeitFetch, nodeFetch };
--- a/packages/now-client/src/utils/index.ts
+++ b/packages/now-client/src/utils/index.ts
@@ -1,6 +1,7 @@
 import { DeploymentFile } from './hashes';
 import { parse as parseUrl } from 'url';
-import fetch_, { RequestInit } from 'node-fetch';
+import { RequestInit } from 'node-fetch';
+import { nodeFetch, zeitFetch } from './fetch';
 import { join, sep } from 'path';
 import qs from 'querystring';
 import ignore from 'ignore';
@@ -85,7 +86,7 @@ export async function getNowIgnore(path: string | string[]): Promise<any> {
    '.wafpicke-*',
    '.lock-wscript',
    '.env',
-    '.env.build',
+    '.env.*',
    '.venv',
    'npm-debug.log',
    'config.gypi',
@@ -122,7 +123,8 @@ export const fetch = async (
  url: string,
  token: string,
  opts: FetchOpts = {},
-  debugEnabled?: boolean
+  debugEnabled?: boolean,
+  useNodeFetch?: boolean
 ): Promise<any> => {
  semaphore.acquire();
  const debug = createDebug(debugEnabled);
@@ -152,7 +154,9 @@ export const fetch = async (

  debug(`${opts.method || 'GET'} ${url}`);
  time = Date.now();
-  const res = await fetch_(url, opts);
+  const res = useNodeFetch
+    ? await nodeFetch(url, opts)
+    : await zeitFetch(url, opts);
  debug(`DONE in ${Date.now() - time}ms: ${opts.method || 'GET'} ${url}`);
  semaphore.release();

--- a/packages/now-next/package.json
+++ b/packages/now-next/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@now/next",
-  "version": "2.3.5",
+  "version": "2.3.7",
  "license": "MIT",
  "main": "./dist/index",
  "homepage": "https://zeit.co/docs/runtimes#official-runtimes/next-js",
--- a/packages/now-next/src/index.ts
+++ b/packages/now-next/src/index.ts
@@ -202,7 +202,7 @@ export const build = async ({
  const pkg = await readPackageJson(entryPath);
  const nextVersion = getNextVersion(pkg);

-  const nodeVersion = await getNodeVersion(entryPath, undefined, config);
+  const nodeVersion = await getNodeVersion(entryPath, undefined, config, meta);
  const spawnOpts = getSpawnOptions(meta, nodeVersion);

  if (!nextVersion) {
--- a/packages/now-node/package.json
+++ b/packages/now-node/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@now/node",
-  "version": "1.3.1",
+  "version": "1.3.3",
  "license": "MIT",
  "main": "./dist/index",
  "homepage": "https://zeit.co/docs/runtimes#official-runtimes/node-js",
--- a/packages/now-node/src/index.ts
+++ b/packages/now-node/src/index.ts
@@ -71,7 +71,8 @@ async function downloadInstallAndBundle({
  const nodeVersion = await getNodeVersion(
    entrypointFsDirname,
    undefined,
-    config
+    config,
+    meta
  );
  const spawnOpts = getSpawnOptions(meta, nodeVersion);
  await runNpmInstall(
@@ -369,16 +370,13 @@ export async function build({
    });
  }

-  // Use the system-installed version of `node` when running via `now dev`
-  const runtime = meta.isDev ? 'nodejs' : nodeVersion.runtime;
-
  const lambda = await createLambda({
    files: {
      ...preparedFiles,
      ...launcherFiles,
    },
    handler: `${LAUNCHER_FILENAME}.launcher`,
-    runtime,
+    runtime: nodeVersion.runtime,
  });

  return { output: lambda, watch };
--- a/packages/now-node/src/typescript.ts
+++ b/packages/now-node/src/typescript.ts
@@ -1,5 +1,6 @@
 import { relative, basename, resolve, dirname } from 'path';
 import _ts from 'typescript';
+import { NowBuildError } from '@now/build-utils';

 /*
 * Fork of TS-Node - https://github.com/TypeStrong/ts-node
@@ -180,8 +181,8 @@ export function register(opts: Options = {}): Register {
  };

  function createTSError(diagnostics: ReadonlyArray<_ts.Diagnostic>) {
-    const diagnosticText = formatDiagnostics(diagnostics, diagnosticHost);
-    return new Error(diagnosticText);
+    const message = formatDiagnostics(diagnostics, diagnosticHost);
+    return new NowBuildError({ code: 'NOW_NODE_TYPESCRIPT_ERROR', message });
  }

  function reportTSError(
--- a/packages/now-node/test/fixtures/10-node-engines/now.json
+++ b/packages/now-node/test/fixtures/10-node-engines/now.json
@@ -7,7 +7,7 @@
    }
  ],
  "probes": [
-    { "path": "/empty", "mustContain": "RANDOMNESS_PLACEHOLDER:8" },
+    { "path": "/empty", "mustContain": "RANDOMNESS_PLACEHOLDER:12" },
    { "path": "/exact", "mustContain": "RANDOMNESS_PLACEHOLDER:10" },
    { "path": "/greater", "mustContain": "RANDOMNESS_PLACEHOLDER:12" },
    { "path": "/major", "mustContain": "RANDOMNESS_PLACEHOLDER:10" },
--- a/packages/now-python/package.json
+++ b/packages/now-python/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@now/python",
-  "version": "1.1.0",
+  "version": "1.1.1-canary.0",
  "main": "./dist/index.js",
  "license": "MIT",
  "homepage": "https://zeit.co/docs/runtimes#official-runtimes/python",
--- a/packages/now-python/src/index.ts
+++ b/packages/now-python/src/index.ts
@@ -36,11 +36,10 @@ export async function downloadFilesInWorkPath({
  files,
  meta,
  config,
-
 }: BuildOptions) {
-    debug('Downloading user files...');
-    let downloadedFiles = await download(files, workPath, meta);
-    if (meta && meta.isDev) {
+  debug('Downloading user files...');
+  let downloadedFiles = await download(files, workPath, meta);
+  if (meta && meta.isDev) {
    let base = null;

    if (config && config.zeroConfig) {
--- a/packages/now-static-build/package.json
+++ b/packages/now-static-build/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@now/static-build",
-  "version": "0.14.1",
+  "version": "0.14.3",
  "license": "MIT",
  "main": "./dist/index",
  "homepage": "https://zeit.co/docs/runtimes#official-runtimes/static-builds",
--- a/packages/now-static-build/src/index.ts
+++ b/packages/now-static-build/src/index.ts
@@ -162,7 +162,13 @@ function getPkg(entrypoint: string, workPath: string) {
  return pkg;
 }

-function getFramework(config: Config | null, pkg?: PackageJson | null) {
+function getFramework(
+  config: Config | null,
+  pkg?: PackageJson | null
+): Framework | undefined {
+  if (!config || !config.zeroConfig) {
+    return;
+  }
  const { framework: configFramework = null } = config || {};

  if (configFramework) {
@@ -294,7 +300,8 @@ export async function build({
    const nodeVersion = await getNodeVersion(
      entrypointDir,
      minNodeRange,
-      config
+      config,
+      meta
    );
    const spawnOpts = getSpawnOptions(meta, nodeVersion);

@@ -447,7 +454,12 @@ export async function build({

  if (!config.zeroConfig && entrypoint.endsWith('.sh')) {
    debug(`Running build script "${entrypoint}"`);
-    const nodeVersion = await getNodeVersion(entrypointDir, undefined, config);
+    const nodeVersion = await getNodeVersion(
+      entrypointDir,
+      undefined,
+      config,
+      meta
+    );
    const spawnOpts = getSpawnOptions(meta, nodeVersion);
    await runShellScript(path.join(workPath, entrypoint), [], spawnOpts);
    validateDistDir(distPath, meta.isDev, config);
--- a/packages/now-static-build/test/fixtures/04a-correct-dist-dir/now.json
+++ b/packages/now-static-build/test/fixtures/04a-correct-dist-dir/now.json
@@ -0,0 +1,11 @@
+{
+  "version": 2,
+  "builds": [
+    {
+      "src": "package.json",
+      "use": "@now/static-build",
+      "config": { "distDir": "out" }
+    }
+  ],
+  "probes": [{ "path": "/", "mustContain": "output:RANDOMNESS_PLACEHOLDER" }]
+}
--- a/packages/now-static-build/test/fixtures/04a-correct-dist-dir/package.json
+++ b/packages/now-static-build/test/fixtures/04a-correct-dist-dir/package.json
@@ -0,0 +1,9 @@
+{
+  "private": true,
+  "scripts": {
+    "now-build": "mkdir out && echo 'output:RANDOMNESS_PLACEHOLDER' > out/index.txt"
+  },
+  "dependencies": {
+    "@vue/cli-service": "3.11.0"
+  }
+}
--- a/packages/now-static-build/test/fixtures/04a-correct-dist-dir/public/index.txt
+++ b/packages/now-static-build/test/fixtures/04a-correct-dist-dir/public/index.txt
@@ -0,0 +1 @@
+Should not use this file
--- a/packages/now-static-build/test/unit.test.js
+++ b/packages/now-static-build/test/unit.test.js
@@ -4,6 +4,7 @@ const path = require('path');
 describe('prepareCache', () => {
  test('should cache node_modules', async () => {
    const files = await prepareCache({
+      config: { zeroConfig: true },
      workPath: path.resolve(__dirname, './cache-fixtures/default'),
      entrypoint: 'index.js',
    });
@@ -14,6 +15,7 @@ describe('prepareCache', () => {

  test('should cache node_modules and `.cache` folder for gatsby deployments', async () => {
    const files = await prepareCache({
+      config: { zeroConfig: true },
      workPath: path.resolve(__dirname, './cache-fixtures/gatsby'),
      entrypoint: 'package.json',
    });
--- a/test/lib/deployment/now-deploy.js
+++ b/test/lib/deployment/now-deploy.js
@@ -1,6 +1,5 @@
 const assert = require('assert');
 const { createHash } = require('crypto');
-const { homedir } = require('os');
 const path = require('path');
 const fetch = require('./fetch-retry.js');

@@ -28,7 +27,7 @@ async function nowDeploy (bodies, randomness) {
        RANDOMNESS_BUILD_ENV_VAR: randomness,
      },
    },
-    name: 'test',
+    name: 'test2020',
    files,
    builds: nowJson.builds,
    routes: nowJson.routes || [],
@@ -133,20 +132,12 @@ async function fetchWithAuth (url, opts = {}) {
  if (!opts.headers) opts.headers = {};

  if (!opts.headers.Authorization) {
-    const { NOW_TOKEN, CIRCLECI } = process.env;
    currentCount += 1;
    if (!token || currentCount === MAX_COUNT) {
      currentCount = 0;
-      if (NOW_TOKEN) {
-        token = NOW_TOKEN;
-      } else if (CIRCLECI) {
-        token = await fetchTokenWithRetry(
-          Buffer.from(str, 'base64').toString()
-        );
-      } else {
-        const authJsonPath = path.join(homedir(), '.now/auth.json');
-        token = require(authJsonPath).token;
-      }
+      token = await fetchTokenWithRetry(
+        Buffer.from(str, 'base64').toString()
+      );
    }

    opts.headers.Authorization = `Bearer ${token}`;
--- a/test/lib/run-build-lambda.js
+++ b/test/lib/run-build-lambda.js
@@ -1,5 +1,8 @@
-const getWritableDirectory = require('../../packages/now-build-utils/fs/get-writable-directory.js');
-const glob = require('../../packages/now-build-utils/fs/glob.js');
+const {
+  getLatestNodeVersion,
+  glob,
+  getWriteableDirectory,
+} = require('@now/build-utils');

 function runAnalyze(wrapper, context) {
  if (wrapper.analyze) {
@@ -16,6 +19,11 @@ async function runBuildLambda(inputPath) {
  const nowJson = require(nowJsonRef.fsPath);
  expect(nowJson.builds.length).toBe(1);
  const build = nowJson.builds[0];
+  if (!build.config || !build.config.nodeVersion) {
+    // Mimic api-deployments when a new project is created
+    const nodeVersion = getLatestNodeVersion().range;
+    build.config = { ...build.config, nodeVersion };
+  }
  expect(build.src.includes('*')).toBeFalsy();
  const entrypoint = build.src.replace(/^\//, ''); // strip leftmost slash
  expect(inputFiles[entrypoint]).toBeDefined();
@@ -26,15 +34,15 @@ async function runBuildLambda(inputPath) {
  const analyzeResult = runAnalyze(wrapper, {
    files: inputFiles,
    entrypoint,
-    config: build.config
+    config: build.config,
  });

-  const workPath = await getWritableDirectory();
+  const workPath = await getWriteableDirectory();
  const buildResult = await wrapper.build({
    files: inputFiles,
    entrypoint,
    config: build.config,
-    workPath
+    workPath,
  });
  const { output } = buildResult;

@@ -43,7 +51,7 @@ async function runBuildLambda(inputPath) {
    buildResult.output = Object.keys(output).reduce(
      (result, path) => ({
        ...result,
-        [path.replace(/\\/g, '/')]: output[path]
+        [path.replace(/\\/g, '/')]: output[path],
      }),
      {}
    );
@@ -52,7 +60,7 @@ async function runBuildLambda(inputPath) {
  return {
    analyzeResult,
    buildResult,
-    workPath
+    workPath,
  };
 }

--- a/yarn.lock
+++ b/yarn.lock
@@ -2023,22 +2023,22 @@
  dependencies:
    "@zeit/dns-cached-resolve" "2.1.0"

-"@zeit/fetch-retry@4.0.0":
-  version "4.0.0"
-  resolved "https://registry.yarnpkg.com/@zeit/fetch-retry/-/fetch-retry-4.0.0.tgz#ad7fe06c4ceb3dcbd76c04db95b1b624ed6fcf3f"
-  integrity sha512-ALXnrCPpiVWha/L3Mm1klPhqmVTKmPQ2dmb5YIsSCrMBJugfhDb42kacVsvQ11vAFRE1LRaJ9Pmw16zEMvQnbw==
+"@zeit/fetch-retry@^4.1.0":
+  version "4.1.0"
+  resolved "https://registry.yarnpkg.com/@zeit/fetch-retry/-/fetch-retry-4.1.0.tgz#a960e335b3ecf01f219e045a4b8819b6ef34b1f4"
+  integrity sha512-2/vtTzIs3/Bp5tNOmCpICCRooa+v0wL4e+3Afl4etyqZrjOmCMfKshWPSHTxLe20qfsn010qXy/hK6yqD4t0zg==
  dependencies:
-    async-retry "^1.1.3"
+    async-retry "^1.3.1"
    debug "^3.1.0"

-"@zeit/fetch@5.1.0":
-  version "5.1.0"
-  resolved "https://registry.yarnpkg.com/@zeit/fetch/-/fetch-5.1.0.tgz#5a24c03ce690f63a81543a016e54aa59f8ca71a0"
-  integrity sha512-e+ZClpgyP8AlOcewSNrpJzXLjPLG+dXBnBg3vYXPYdYItj2dWaI1mRjiyBriH/U9Gt48wZJukz9Q3uhMYS4X6w==
+"@zeit/fetch@5.2.0":
+  version "5.2.0"
+  resolved "https://registry.yarnpkg.com/@zeit/fetch/-/fetch-5.2.0.tgz#7a8bfa31284e33a4e3fe7940351b0d48264d167d"
+  integrity sha512-S4TFaT210j/lgzHjaxN2SiaMxXGeoB4hghNlhlvSqwTFSDNIqyJIDKFZQy+r3NKJOQU+RB5yGKJt8LS1pPHUrw==
  dependencies:
    "@types/async-retry" "1.2.1"
    "@zeit/fetch-cached-dns" "1.2.0"
-    "@zeit/fetch-retry" "4.0.0"
+    "@zeit/fetch-retry" "^4.1.0"
    agentkeepalive "3.4.1"
    debug "3.1.0"

@@ -2341,9 +2341,9 @@ ansi-styles@^4.0.0:
    color-convert "^2.0.1"

 ansi-styles@^4.1.0:
-  version "4.2.0"
-  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.2.0.tgz#5681f0dcf7ae5880a7841d8831c4724ed9cc0172"
-  integrity sha512-7kFQgnEaMdRtwf6uSfUnVr9gSGC7faurn+J/Mv90/W+iTtN0405/nLdopfMWwchyxhbGYl6TC4Sccn9TUkGAgg==
+  version "4.2.1"
+  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-4.2.1.tgz#90ae75c424d008d2624c5bf29ead3177ebfcf359"
+  integrity sha512-9VGjrMsG1vePxcSweQsN20KY/c4zN0h9fLjqAbwbPfahM3t+NL+M9HC8xeXG2I8pX5NoamTGNuomEUFI7fcUjA==
  dependencies:
    "@types/color-name" "^1.1.1"
    color-convert "^2.0.1"
@@ -2590,13 +2590,20 @@ async-retry@1.1.3:
  dependencies:
    retry "0.10.1"

-async-retry@1.2.3, async-retry@^1.1.3:
+async-retry@1.2.3:
  version "1.2.3"
  resolved "https://registry.yarnpkg.com/async-retry/-/async-retry-1.2.3.tgz#a6521f338358d322b1a0012b79030c6f411d1ce0"
  integrity sha512-tfDb02Th6CE6pJUF2gjW5ZVjsgwlucVXOEQMvEX9JgSJMs9gAX+Nz3xRuJBKuUYjTSYORqvDBORdAQ3LU59g7Q==
  dependencies:
    retry "0.12.0"

+async-retry@^1.3.1:
+  version "1.3.1"
+  resolved "https://registry.yarnpkg.com/async-retry/-/async-retry-1.3.1.tgz#139f31f8ddce50c0870b0ba558a6079684aaed55"
+  integrity sha512-aiieFW/7h3hY0Bq5d+ktDBejxuwR78vRu9hDUdR8rNhSaQ29VzPL4AoIRG7D/c7tdenwOcKvgPM6tIxB3cB6HA==
+  dependencies:
+    retry "0.12.0"
+
 async-sema@2.1.4:
  version "2.1.4"
  resolved "https://registry.yarnpkg.com/async-sema/-/async-sema-2.1.4.tgz#3f5aa091d0a763354045ee899a5d17ffb69251af"
@@ -9731,7 +9738,7 @@ shellwords@^0.1.1:
  resolved "https://registry.yarnpkg.com/shellwords/-/shellwords-0.1.1.tgz#d6b9181c1a48d397324c84871efbcfc73fc0654b"
  integrity sha512-vFwSUfQvqybiICwZY5+DAWIPLKsWO31Q91JSKl3UYv+K5c2QRPzn0qzec6QPu1Qc9eHYItiP3NdJqNVqetYAww==

-signal-exit@3.0.2, signal-exit@TooTallNate/signal-exit#update/sighub-to-sigint-on-windows, signal-exit@^3.0.0, signal-exit@^3.0.2:
+signal-exit@3.0.2, signal-exit@^3.0.0, signal-exit@^3.0.2:
  version "3.0.2"
  resolved "https://codeload.github.com/TooTallNate/signal-exit/tar.gz/58088fa7f715149f8411e089a4a6e3fe6ed265ec"

@@ -10411,9 +10418,9 @@ term-size@^1.2.0:
    execa "^0.7.0"

 term-size@^2.1.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/term-size/-/term-size-2.1.0.tgz#3aec444c07a7cf936e157c1dc224b590c3c7eef2"
-  integrity sha512-I42EWhJ+2aeNQawGx1VtpO0DFI9YcfuvAMNIdKyf/6sRbHJ4P+ZQ/zIT87tE+ln1ymAGcCJds4dolfSAS0AcNg==
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/term-size/-/term-size-2.1.1.tgz#f81ec25854af91a480d2f9d0c77ffcb26594ed1a"
+  integrity sha512-UqvQSch04R+69g4RDhrslmGvGL3ucDRX/U+snYW0Mab4uCAyKSndUksaoqlJ81QKSpRnIsuOYQCbC2ZWx2896A==

 test-exclude@^5.1.0, test-exclude@^5.2.3:
  version "5.2.3"
Author	SHA1	Message	Date
Steven	46c8cb1a68	Publish Stable - @now/build-utils@1.3.2 - @now/next@2.3.7 - @now/node@1.3.3 - @now/static-build@0.14.3	2020-01-06 18:44:26 -05:00
Steven	faeb053ea6	Publish Canary - @now/build-utils@1.3.2-canary.1 - now@16.7.2-canary.3 - @now/next@2.3.7-canary.1 - @now/node@1.3.3-canary.1 - @now/static-build@0.14.3-canary.1	2020-01-06 18:30:34 -05:00
Steven	708a09b86a	[now-build-utils] Add usage of package.json engines (#3512 ) Add a better upgrade message that shows usage of `engines` in the `package.json` file.	2020-01-06 18:29:08 -05:00
Steven	89403e93e4	Publish Canary - @now/build-utils@1.3.2-canary.0 - @now/next@2.3.7-canary.0 - @now/node@1.3.3-canary.0 - @now/static-build@0.14.3-canary.0	2020-01-06 17:01:47 -05:00
Steven	ecb0c08fe2	[now-build-utils] Fix now dev to use system node (#3509 ) This PR will use the system installed version of Node.js and avoid printing a warning or error if a discontinued version is selected. This optimization was already in `@now/node` but for some reason it was never add to `@now/next`. The reason why its relevant today is because the warnings turned into errors due to Node 8 deprecation and we don't have the "Project" in `now dev` so we don't know which version of node to select. So instead of determining the version, `now dev` will always use `node` in the PATH and avoid printing warnings or errors. This also results in less FS reads since we no longer need to read package.json.	2020-01-06 17:00:46 -05:00
Andy Bitz	0b88c158b9	Publish Stable - @now/frameworks@0.0.3	2020-01-06 20:15:04 +01:00
Andy	ec3a38107a	[frameworks] Add `settings` to frameworks (#3506 ) * [frameworks] Add `settings` to frameworks * Fix svelte * Add `outputDirectory` * Update Next.js outputDirectory placeholder * Type settings Co-authored-by: Leo Lamprecht <mindrun@icloud.com>	2020-01-06 20:12:38 +01:00
Steven	0c0f1c6eb5	Publish Stable - @now/build-utils@1.3.1 - @now/next@2.3.6 - @now/node@1.3.2 - @now/static-build@0.14.2	2020-01-06 13:21:41 -05:00
Steven	ed296ef733	Publish Canary - @now/build-utils@1.3.1-canary.1 - now@16.7.2-canary.2 - @now/static-build@0.14.2-canary.0	2020-01-06 13:10:05 -05:00
Steven	246f47ec95	[now-static-build] Fix `distDir` when zero config framework is detected (#3507 ) There was a regression with framework detection that was preferring the frameworks output directory instead of the `distDir` defined in the `@now/static-build`. The fix is to only run framework detection when `builds` is not defined (ie zero config). Related to https://github.com/Ebury/chameleon/pull/63	2020-01-06 18:07:25 +00:00
Steven	9d95b99b72	[now-build-utils] Add support for dynamic `handle: miss` (#3457 ) This extends the behavior of `featHandleMiss: true` flag to do the following: - Reduce zero config API routes so that only dynamic path segment files (`api/[id].js`) get a route. - Remove zero config out directory route (`public/`)—the files will be renamed instead. - Use redirects for API routes when `cleanUrls: true` and use rewrites when `cleanUrls: false` from extension to the extension-less file. - Normalize existing routes to begin with `^` and end with `$`.	2020-01-06 16:07:47 +00:00
Steven	3de8ae9d7e	Publish Canary - @now/build-utils@1.3.1-canary.0 - @now/node@1.3.2-canary.0	2020-01-06 10:19:23 -05:00
Steven	44f6e1904e	[now-build-utils][now-node] Throw new NowBuildError() (#3496 ) This PR does the following - Add and export class, `NowBuildError`, that can be thrown to stop the build and print an error but it will not print a stack trace. - Improve logic for discontinued node versions and add more tests - Remove hack (#3425) for undefined TERM, fixed by updating dependencies - Rename `silent` variable to `isAuto` which means the node version was automatically selected, not defined in `package.json` - Rename `test` deployments to `test2020` so that a fresh project is created with latest Node.js 12.x	2020-01-06 15:00:27 +00:00
Max Rovensky	d9c84fc4ce	Publish Canary - now@16.7.2-canary.1 - @now/python@1.1.1-canary.0	2020-01-06 21:45:01 +08:00
Max	b5142d935b	Fix event order in CLI (#3502 ) This should fix [PRODUCT-893](https://zeit.atlassian.net/browse/PRODUCT-893) and [PRODUCT-941](https://zeit.atlassian.net/browse/PRODUCT-941)	2020-01-06 13:43:44 +00:00
luc	718a451110	Publish Canary - now@16.7.2-canary.0 - now-client@6.0.2-canary.0	2020-01-06 11:24:45 +01:00
Andy	9755847855	[now-client] Ignore `.env.` files by default (#3436 ) Ignore `.env.` files by default. [PRODUCT-804] [PRODUCT-804]: https://zeit.atlassian.net/browse/PRODUCT-804	2020-01-06 10:19:55 +00:00
Luc	abc417b6b3	[now-client] Use `@zeit/fetch` instead of `node-fetch` (#3490 ) We want to take advantage of the better defaults and retry policies (among others). This bumps `@zeit/fetch` and replaces `node-fetch` with `@zeit/fetch` in `now-client`. Also update retry policy for "uploading" files to: - base 10ms - 5 retries - factor 6 which means the timeouts are 10, 60, 360, 2160, 12960	2020-01-06 09:01:17 +00:00