Publish Stable

- @vercel/build-utils@5.9.0
 - vercel@28.12.6
 - @vercel/client@12.3.1
 - @vercel/fs-detectors@3.7.5
 - @vercel/go@2.2.30
 - @vercel/hydrogen@0.0.44
 - @vercel/next@3.3.15
 - @vercel/node@2.8.13
 - @vercel/python@3.1.40
 - @vercel/redwood@1.0.51
 - @vercel/remix@1.2.5
 - @vercel/ruby@1.3.56
 - @vercel/static-build@1.1.7

api/package.json

@@ -4,8 +4,7 @@
   "version": "0.0.0",
   "description": "API for the vercel/vercel repo",
   "main": "index.js",
-  "scripts": {
-  },
+  "scripts": {},
   "dependencies": {
     "@sentry/node": "5.11.1",
     "got": "10.2.1",
@@ -17,7 +16,7 @@
   "devDependencies": {
     "@types/node": "16.18.11",
     "@types/node-fetch": "2.5.4",
-    "@vercel/node": "workspace:2.8.6",
+    "@vercel/node": "*",
     "typescript": "4.3.4"
   }
 }

package.json

@@ -11,9 +11,9 @@
     "@types/node": "14.18.33",
     "@typescript-eslint/eslint-plugin": "5.21.0",
     "@typescript-eslint/parser": "5.21.0",
-    "@vercel/build-utils": "workspace:5.7.5",
+    "@vercel/build-utils": "*",
     "@vercel/ncc": "0.24.0",
-    "@vercel/next": "workspace:3.3.9",
+    "@vercel/next": "*",
     "async-retry": "1.2.3",
     "buffer-replace": "1.0.0",
     "create-svelte": "2.0.1",
@@ -37,6 +37,7 @@
   },
   "scripts": {
     "lerna": "lerna",
+    "version": "pnpm install && git add pnpm-lock.yaml",
     "bootstrap": "lerna bootstrap",
     "publish-stable": "echo 'Run `pnpm changelog` for instructions'",
     "publish-canary": "git checkout main && git pull && lerna version prerelease --preid canary --message \"Publish Canary\" --exact",

packages/build-utils/package.json

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

packages/build-utils/src/fs/download.ts

@@ -2,7 +2,7 @@ import path from 'path';
 import debug from '../debug';
 import FileFsRef from '../file-fs-ref';
 import { File, Files, Meta } from '../types';
-import { remove, mkdirp, readlink, symlink } from 'fs-extra';
+import { remove, mkdirp, readlink, symlink, chmod } from 'fs-extra';
 import streamToBuffer from './stream-to-buffer';
 
 export interface DownloadedFiles {
@@ -51,6 +51,12 @@ export async function downloadFile(
 ): Promise<FileFsRef> {
   const { mode } = file;
 
+  if (isDirectory(mode)) {
+    await mkdirp(fsPath);
+    await chmod(fsPath, mode);
+    return FileFsRef.fromFsPath({ mode, fsPath });
+  }
+
   // If the source is a symlink, try to create it instead of copying the file.
   // Note: creating symlinks on Windows requires admin priviliges or symlinks
   // enabled in the group policy. We may want to improve the error message.

packages/build-utils/src/fs/glob.ts

@@ -6,7 +6,9 @@ import { lstat, Stats } from 'fs-extra';
 import { normalizePath } from './normalize-path';
 import FileFsRef from '../file-fs-ref';
 
-export type GlobOptions = vanillaGlob_.IOptions;
+export interface GlobOptions extends vanillaGlob_.IOptions {
+  includeDirectories?: boolean;
+}
 
 const vanillaGlob = promisify(vanillaGlob_);
 
@@ -15,12 +17,7 @@ export default async function glob(
   opts: GlobOptions | string,
   mountpoint?: string
 ): Promise<Record<string, FileFsRef>> {
-  let options: GlobOptions;
-  if (typeof opts === 'string') {
-    options = { cwd: opts };
-  } else {
-    options = opts;
-  }
+  const options = typeof opts === 'string' ? { cwd: opts } : opts;
 
   if (!options.cwd) {
     throw new Error(
@@ -34,13 +31,18 @@ export default async function glob(
 
   const results: Record<string, FileFsRef> = {};
   const statCache: Record<string, Stats> = {};
+  const symlinks: Record<string, boolean | undefined> = {};
 
-  options.symlinks = {};
-  options.statCache = statCache;
-  options.stat = true;
-  options.dot = true;
+  const files = await vanillaGlob(pattern, {
+    ...options,
+    symlinks,
+    statCache,
+    stat: true,
+    dot: true,
+  });
 
-  const files = await vanillaGlob(pattern, options);
+  const dirs = new Set<string>();
+  const dirsWithEntries = new Set<string>();
 
   for (const relativePath of files) {
     const fsPath = normalizePath(path.join(options.cwd, relativePath));
@@ -49,12 +51,20 @@ export default async function glob(
       stat,
       `statCache does not contain value for ${relativePath} (resolved to ${fsPath})`
     );
-    const isSymlink = options.symlinks![fsPath];
-    if (isSymlink || stat.isFile()) {
+    const isSymlink = symlinks[fsPath];
+    if (isSymlink || stat.isFile() || stat.isDirectory()) {
       if (isSymlink) {
         stat = await lstat(fsPath);
       }
 
+      // Some bookkeeping to track which directories already have entries within
+      const dirname = path.dirname(relativePath);
+      dirsWithEntries.add(dirname);
+      if (stat.isDirectory()) {
+        dirs.add(relativePath);
+        continue;
+      }
+
       let finalPath = relativePath;
       if (mountpoint) {
         finalPath = path.join(mountpoint, finalPath);
@@ -64,5 +74,22 @@ export default async function glob(
     }
   }
 
+  // Add empty directory entries
+  if (options.includeDirectories) {
+    for (const relativePath of dirs) {
+      if (dirsWithEntries.has(relativePath)) continue;
+
+      let finalPath = relativePath;
+      if (mountpoint) {
+        finalPath = path.join(mountpoint, finalPath);
+      }
+
+      const fsPath = normalizePath(path.join(options.cwd, relativePath));
+      const stat = statCache[fsPath];
+
+      results[finalPath] = new FileFsRef({ mode: stat.mode, fsPath });
+    }
+  }
+
   return results;
 }

packages/build-utils/src/index.ts

@@ -8,6 +8,7 @@ import download, {
   downloadFile,
   DownloadedFiles,
   isSymbolicLink,
+  isDirectory,
 } from './fs/download';
 import getWriteableDirectory from './fs/get-writable-directory';
 import glob, { GlobOptions } from './fs/glob';
@@ -82,6 +83,7 @@ export {
   streamToBuffer,
   debug,
   isSymbolicLink,
+  isDirectory,
   getLambdaOptionsFromFunction,
   scanParentDirs,
   getIgnoreFilter,

packages/build-utils/test/unit.download.test.ts

@@ -0,0 +1,195 @@
+import path from 'path';
+import fs, { readlink } from 'fs-extra';
+import { strict as assert, strictEqual } from 'assert';
+import { download, glob, FileBlob } from '../src';
+
+describe('download()', () => {
+  let warningMessages: string[];
+  const originalConsoleWarn = console.warn;
+  beforeEach(() => {
+    warningMessages = [];
+    console.warn = m => {
+      warningMessages.push(m);
+    };
+  });
+
+  afterEach(() => {
+    console.warn = originalConsoleWarn;
+  });
+
+  it('should re-create FileFsRef symlinks properly', async () => {
+    if (process.platform === 'win32') {
+      console.log('Skipping test on windows');
+      return;
+    }
+    const files = await glob('**', path.join(__dirname, 'symlinks'));
+    assert.equal(Object.keys(files).length, 4);
+
+    const outDir = path.join(__dirname, 'symlinks-out');
+    await fs.remove(outDir);
+
+    const files2 = await download(files, outDir);
+    assert.equal(Object.keys(files2).length, 4);
+
+    const [linkStat, linkDirStat, aStat] = await Promise.all([
+      fs.lstat(path.join(outDir, 'link.txt')),
+      fs.lstat(path.join(outDir, 'link-dir')),
+      fs.lstat(path.join(outDir, 'a.txt')),
+    ]);
+    assert(linkStat.isSymbolicLink());
+    assert(linkDirStat.isSymbolicLink());
+    assert(aStat.isFile());
+
+    const [linkDirContents, linkTextContents] = await Promise.all([
+      readlink(path.join(outDir, 'link-dir')),
+      readlink(path.join(outDir, 'link.txt')),
+    ]);
+
+    strictEqual(linkDirContents, 'dir');
+    strictEqual(linkTextContents, './a.txt');
+  });
+
+  it('should re-create FileBlob symlinks properly', async () => {
+    if (process.platform === 'win32') {
+      console.log('Skipping test on windows');
+      return;
+    }
+
+    const files = {
+      'a.txt': new FileBlob({
+        mode: 33188,
+        contentType: undefined,
+        data: 'a text',
+      }),
+      'dir/b.txt': new FileBlob({
+        mode: 33188,
+        contentType: undefined,
+        data: 'b text',
+      }),
+      'link-dir': new FileBlob({
+        mode: 41453,
+        contentType: undefined,
+        data: 'dir',
+      }),
+      'link.txt': new FileBlob({
+        mode: 41453,
+        contentType: undefined,
+        data: 'a.txt',
+      }),
+    };
+
+    strictEqual(Object.keys(files).length, 4);
+
+    const outDir = path.join(__dirname, 'symlinks-out');
+    await fs.remove(outDir);
+
+    const files2 = await download(files, outDir);
+    strictEqual(Object.keys(files2).length, 4);
+
+    const [linkStat, linkDirStat, aStat, dirStat] = await Promise.all([
+      fs.lstat(path.join(outDir, 'link.txt')),
+      fs.lstat(path.join(outDir, 'link-dir')),
+      fs.lstat(path.join(outDir, 'a.txt')),
+      fs.lstat(path.join(outDir, 'dir')),
+    ]);
+
+    assert(linkStat.isSymbolicLink());
+    assert(linkDirStat.isSymbolicLink());
+    assert(aStat.isFile());
+    assert(dirStat.isDirectory());
+
+    const [linkDirContents, linkTextContents] = await Promise.all([
+      readlink(path.join(outDir, 'link-dir')),
+      readlink(path.join(outDir, 'link.txt')),
+    ]);
+
+    strictEqual(linkDirContents, 'dir');
+    strictEqual(linkTextContents, 'a.txt');
+  });
+
+  it('should download symlinks even with incorrect file', async () => {
+    if (process.platform === 'win32') {
+      console.log('Skipping test on windows');
+      return;
+    }
+    const files = {
+      'dir/file.txt': new FileBlob({
+        mode: 33188,
+        contentType: undefined,
+        data: 'file text',
+      }),
+      linkdir: new FileBlob({
+        mode: 41453,
+        contentType: undefined,
+        data: 'dir',
+      }),
+      'linkdir/file.txt': new FileBlob({
+        mode: 33188,
+        contentType: undefined,
+        data: 'this file should be discarded',
+      }),
+    };
+
+    const outDir = path.join(__dirname, 'symlinks-out');
+    await fs.remove(outDir);
+    await fs.mkdirp(outDir);
+
+    await download(files, outDir);
+
+    const [dir, file, linkdir] = await Promise.all([
+      fs.lstat(path.join(outDir, 'dir')),
+      fs.lstat(path.join(outDir, 'dir/file.txt')),
+      fs.lstat(path.join(outDir, 'linkdir')),
+    ]);
+    expect(dir.isFile()).toBe(false);
+    expect(dir.isSymbolicLink()).toBe(false);
+
+    expect(file.isFile()).toBe(true);
+    expect(file.isSymbolicLink()).toBe(false);
+
+    expect(linkdir.isSymbolicLink()).toBe(true);
+
+    expect(warningMessages).toEqual([
+      'Warning: file "linkdir/file.txt" is within a symlinked directory "linkdir" and will be ignored',
+    ]);
+  });
+
+  it('should create empty directory entries', async () => {
+    const outDir = path.join(__dirname, 'symlinks-out');
+    await fs.remove(outDir);
+    const files = {
+      'empty-dir': new FileBlob({
+        mode: 16877, // drwxr-xr-x
+        contentType: undefined,
+        data: '',
+      }),
+      dir: new FileBlob({
+        mode: 16877,
+        contentType: undefined,
+        data: '',
+      }),
+      'dir/subdir': new FileBlob({
+        mode: 16877,
+        contentType: undefined,
+        data: '',
+      }),
+      'another/subdir': new FileBlob({
+        mode: 16895, // drwxrwxrwx
+        contentType: undefined,
+        data: '',
+      }),
+    };
+
+    await download(files, outDir);
+
+    for (const [p, f] of Object.entries(files)) {
+      const stat = await fs.lstat(path.join(outDir, p));
+      expect(stat.isDirectory()).toEqual(true);
+
+      if (process.platform !== 'win32') {
+        // Don't test Windows since it doesn't support the same permissions
+        expect(stat.mode).toEqual(f.mode);
+      }
+    }
+  });
+});

packages/build-utils/test/unit.glob.test.ts

@@ -0,0 +1,65 @@
+import fs from 'fs-extra';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { glob, isDirectory } from '../src';
+
+describe('glob()', () => {
+  it('should not return entries for empty directories by default', async () => {
+    const dir = await fs.mkdtemp(join(tmpdir(), 'build-utils-test'));
+    try {
+      await Promise.all([
+        fs.writeFile(join(dir, 'root.txt'), 'file at the root'),
+        fs.mkdirp(join(dir, 'empty-dir')),
+        fs
+          .mkdirp(join(dir, 'dir-with-file'))
+          .then(() =>
+            fs.writeFile(join(dir, 'dir-with-file/data.json'), '{"a":"b"}')
+          ),
+        fs.mkdirp(join(dir, 'another/subdir')),
+      ]);
+      const files = await glob('**', dir);
+      const fileNames = Object.keys(files).sort();
+      expect(fileNames).toHaveLength(2);
+      expect(fileNames).toEqual(['dir-with-file/data.json', 'root.txt']);
+      expect(isDirectory(files['dir-with-file/data.json'].mode)).toEqual(false);
+      expect(isDirectory(files['root.txt'].mode)).toEqual(false);
+      expect(files['dir-with-file']).toBeUndefined();
+      expect(files['another/subdir']).toBeUndefined();
+      expect(files['empty-dir']).toBeUndefined();
+    } finally {
+      await fs.remove(dir);
+    }
+  });
+
+  it('should return entries for empty directories with `includeDirectories: true`', async () => {
+    const dir = await fs.mkdtemp(join(tmpdir(), 'build-utils-test'));
+    try {
+      await Promise.all([
+        fs.writeFile(join(dir, 'root.txt'), 'file at the root'),
+        fs.mkdirp(join(dir, 'empty-dir')),
+        fs
+          .mkdirp(join(dir, 'dir-with-file'))
+          .then(() =>
+            fs.writeFile(join(dir, 'dir-with-file/data.json'), '{"a":"b"}')
+          ),
+        fs.mkdirp(join(dir, 'another/subdir')),
+      ]);
+      const files = await glob('**', { cwd: dir, includeDirectories: true });
+      const fileNames = Object.keys(files).sort();
+      expect(fileNames).toHaveLength(4);
+      expect(fileNames).toEqual([
+        'another/subdir',
+        'dir-with-file/data.json',
+        'empty-dir',
+        'root.txt',
+      ]);
+      expect(isDirectory(files['another/subdir'].mode)).toEqual(true);
+      expect(isDirectory(files['empty-dir'].mode)).toEqual(true);
+      expect(isDirectory(files['dir-with-file/data.json'].mode)).toEqual(false);
+      expect(isDirectory(files['root.txt'].mode)).toEqual(false);
+      expect(files['dir-with-file']).toBeUndefined();
+    } finally {
+      await fs.remove(dir);
+    }
+  });
+});

packages/build-utils/test/unit.test.ts

@@ -1,18 +1,15 @@
 import ms from 'ms';
 import path from 'path';
-import fs, { readlink } from 'fs-extra';
-import { strict as assert, strictEqual } from 'assert';
+import fs from 'fs-extra';
+import { strict as assert } from 'assert';
 import { getSupportedNodeVersion } from '../src/fs/node-version';
-import download from '../src/fs/download';
 import {
-  glob,
   getNodeVersion,
   getLatestNodeVersion,
   getDiscontinuedNodeVersions,
   runNpmInstall,
   runPackageJsonScript,
   scanParentDirs,
-  FileBlob,
   Prerender,
 } from '../src';
 
@@ -49,143 +46,6 @@ afterEach(() => {
   console.warn = originalConsoleWarn;
 });
 
-it('should re-create FileFsRef symlinks properly', async () => {
-  if (process.platform === 'win32') {
-    console.log('Skipping test on windows');
-    return;
-  }
-  const files = await glob('**', path.join(__dirname, 'symlinks'));
-  assert.equal(Object.keys(files).length, 4);
-
-  const outDir = path.join(__dirname, 'symlinks-out');
-  await fs.remove(outDir);
-
-  const files2 = await download(files, outDir);
-  assert.equal(Object.keys(files2).length, 4);
-
-  const [linkStat, linkDirStat, aStat] = await Promise.all([
-    fs.lstat(path.join(outDir, 'link.txt')),
-    fs.lstat(path.join(outDir, 'link-dir')),
-    fs.lstat(path.join(outDir, 'a.txt')),
-  ]);
-  assert(linkStat.isSymbolicLink());
-  assert(linkDirStat.isSymbolicLink());
-  assert(aStat.isFile());
-
-  const [linkDirContents, linkTextContents] = await Promise.all([
-    readlink(path.join(outDir, 'link-dir')),
-    readlink(path.join(outDir, 'link.txt')),
-  ]);
-
-  strictEqual(linkDirContents, 'dir');
-  strictEqual(linkTextContents, './a.txt');
-});
-
-it('should re-create FileBlob symlinks properly', async () => {
-  if (process.platform === 'win32') {
-    console.log('Skipping test on windows');
-    return;
-  }
-
-  const files = {
-    'a.txt': new FileBlob({
-      mode: 33188,
-      contentType: undefined,
-      data: 'a text',
-    }),
-    'dir/b.txt': new FileBlob({
-      mode: 33188,
-      contentType: undefined,
-      data: 'b text',
-    }),
-    'link-dir': new FileBlob({
-      mode: 41453,
-      contentType: undefined,
-      data: 'dir',
-    }),
-    'link.txt': new FileBlob({
-      mode: 41453,
-      contentType: undefined,
-      data: 'a.txt',
-    }),
-  };
-
-  strictEqual(Object.keys(files).length, 4);
-
-  const outDir = path.join(__dirname, 'symlinks-out');
-  await fs.remove(outDir);
-
-  const files2 = await download(files, outDir);
-  strictEqual(Object.keys(files2).length, 4);
-
-  const [linkStat, linkDirStat, aStat, dirStat] = await Promise.all([
-    fs.lstat(path.join(outDir, 'link.txt')),
-    fs.lstat(path.join(outDir, 'link-dir')),
-    fs.lstat(path.join(outDir, 'a.txt')),
-    fs.lstat(path.join(outDir, 'dir')),
-  ]);
-
-  assert(linkStat.isSymbolicLink());
-  assert(linkDirStat.isSymbolicLink());
-  assert(aStat.isFile());
-  assert(dirStat.isDirectory());
-
-  const [linkDirContents, linkTextContents] = await Promise.all([
-    readlink(path.join(outDir, 'link-dir')),
-    readlink(path.join(outDir, 'link.txt')),
-  ]);
-
-  strictEqual(linkDirContents, 'dir');
-  strictEqual(linkTextContents, 'a.txt');
-});
-
-it('should download symlinks even with incorrect file', async () => {
-  if (process.platform === 'win32') {
-    console.log('Skipping test on windows');
-    return;
-  }
-  const files = {
-    'dir/file.txt': new FileBlob({
-      mode: 33188,
-      contentType: undefined,
-      data: 'file text',
-    }),
-    linkdir: new FileBlob({
-      mode: 41453,
-      contentType: undefined,
-      data: 'dir',
-    }),
-    'linkdir/file.txt': new FileBlob({
-      mode: 33188,
-      contentType: undefined,
-      data: 'this file should be discarded',
-    }),
-  };
-
-  const outDir = path.join(__dirname, 'symlinks-out');
-  await fs.remove(outDir);
-  await fs.mkdirp(outDir);
-
-  await download(files, outDir);
-
-  const [dir, file, linkdir] = await Promise.all([
-    fs.lstat(path.join(outDir, 'dir')),
-    fs.lstat(path.join(outDir, 'dir/file.txt')),
-    fs.lstat(path.join(outDir, 'linkdir')),
-  ]);
-  expect(dir.isFile()).toBe(false);
-  expect(dir.isSymbolicLink()).toBe(false);
-
-  expect(file.isFile()).toBe(true);
-  expect(file.isSymbolicLink()).toBe(false);
-
-  expect(linkdir.isSymbolicLink()).toBe(true);
-
-  expect(warningMessages).toEqual([
-    'Warning: file "linkdir/file.txt" is within a symlinked directory "linkdir" and will be ignored',
-  ]);
-});
-
 it('should only match supported node versions, otherwise throw an error', async () => {
   expect(await getSupportedNodeVersion('14.x', false)).toHaveProperty(
     'major',

packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vercel",
-  "version": "28.12.0",
+  "version": "28.12.6",
   "preferGlobal": true,
   "license": "Apache-2.0",
   "description": "The command-line interface for Vercel",
@@ -41,16 +41,16 @@
     "node": ">= 14"
   },
   "dependencies": {
-    "@vercel/build-utils": "workspace:5.7.6",
-    "@vercel/go": "workspace:2.2.25",
-    "@vercel/hydrogen": "workspace:0.0.39",
-    "@vercel/next": "workspace:3.3.10",
-    "@vercel/node": "workspace:2.8.7",
-    "@vercel/python": "workspace:3.1.35",
-    "@vercel/redwood": "workspace:1.0.46",
-    "@vercel/remix": "workspace:1.2.0",
-    "@vercel/ruby": "workspace:1.3.51",
-    "@vercel/static-build": "workspace:1.1.2"
+    "@vercel/build-utils": "5.9.0",
+    "@vercel/go": "2.2.30",
+    "@vercel/hydrogen": "0.0.44",
+    "@vercel/next": "3.3.15",
+    "@vercel/node": "2.8.13",
+    "@vercel/python": "3.1.40",
+    "@vercel/redwood": "1.0.51",
+    "@vercel/remix": "1.2.5",
+    "@vercel/ruby": "1.3.56",
+    "@vercel/static-build": "1.1.7"
   },
   "devDependencies": {
     "@alex_neo/jest-expect-message": "1.0.5",
@@ -93,13 +93,13 @@
     "@types/which": "1.3.2",
     "@types/write-json-file": "2.2.1",
     "@types/yauzl-promise": "2.1.0",
-    "@vercel/client": "workspace:12.2.27",
-    "@vercel/error-utils": "workspace:1.0.4",
-    "@vercel/frameworks": "workspace:1.2.0",
-    "@vercel/fs-detectors": "workspace:3.7.0",
+    "@vercel/client": "12.3.1",
+    "@vercel/error-utils": "1.0.8",
+    "@vercel/frameworks": "1.2.4",
+    "@vercel/fs-detectors": "3.7.5",
     "@vercel/fun": "1.0.4",
     "@vercel/ncc": "0.24.0",
-    "@vercel/routing-utils": "workspace:2.1.4",
+    "@vercel/routing-utils": "2.1.8",
     "@zeit/source-map-support": "0.6.2",
     "ajv": "6.12.2",
     "alpha-sort": "2.0.1",

packages/cli/test/dev/integration-2.test.ts

@@ -1,16 +1,4 @@
-import { join } from 'path';
-import ms from 'ms';
-import fs, { mkdirp } from 'fs-extra';
-
-const {
-  exec,
-  fetch,
-  fixture,
-  sleep,
-  testFixture,
-  testFixtureStdio,
-  validateResponseHeaders,
-} = require('./utils.js');
+const { exec, fixture, testFixture, testFixtureStdio } = require('./utils.js');
 
 test('[vercel dev] validate redirects', async () => {
   const directory = fixture('invalid-redirects');
@@ -122,262 +110,3 @@ test(
     });
   })
 );
-
-test(
-  '[vercel dev] test cleanUrls serve correct content',
-  testFixtureStdio('test-clean-urls', async (testPath: any) => {
-    await testPath(200, '/', 'Index Page');
-    await testPath(200, '/about', 'About Page');
-    await testPath(200, '/sub', 'Sub Index Page');
-    await testPath(200, '/sub/another', 'Sub Another Page');
-    await testPath(200, '/style.css', 'body { color: green }');
-    await testPath(308, '/index.html', 'Redirecting to / (308)', {
-      Location: '/',
-    });
-    await testPath(308, '/about.html', 'Redirecting to /about (308)', {
-      Location: '/about',
-    });
-    await testPath(308, '/sub/index.html', 'Redirecting to /sub (308)', {
-      Location: '/sub',
-    });
-    await testPath(
-      308,
-      '/sub/another.html',
-      'Redirecting to /sub/another (308)',
-      { Location: '/sub/another' }
-    );
-  })
-);
-
-test(
-  '[vercel dev] test cleanUrls serve correct content when using `outputDirectory`',
-  testFixtureStdio(
-    'test-clean-urls-with-output-directory',
-    async (testPath: any) => {
-      await testPath(200, '/', 'Index Page');
-      await testPath(200, '/about', 'About Page');
-      await testPath(200, '/sub', 'Sub Index Page');
-      await testPath(200, '/sub/another', 'Sub Another Page');
-      await testPath(200, '/style.css', 'body { color: green }');
-      await testPath(308, '/index.html', 'Redirecting to / (308)', {
-        Location: '/',
-      });
-      await testPath(308, '/about.html', 'Redirecting to /about (308)', {
-        Location: '/about',
-      });
-      await testPath(308, '/sub/index.html', 'Redirecting to /sub (308)', {
-        Location: '/sub',
-      });
-      await testPath(
-        308,
-        '/sub/another.html',
-        'Redirecting to /sub/another (308)',
-        { Location: '/sub/another' }
-      );
-    }
-  )
-);
-
-test(
-  '[vercel dev] should serve custom 404 when `cleanUrls: true`',
-  testFixtureStdio('test-clean-urls-custom-404', async (testPath: any) => {
-    await testPath(200, '/', 'This is the home page');
-    await testPath(200, '/about', 'The about page');
-    await testPath(200, '/contact/me', 'Contact Me Subdirectory');
-    await testPath(404, '/nothing', 'Custom 404 Page');
-    await testPath(404, '/nothing/', 'Custom 404 Page');
-  })
-);
-
-test(
-  '[vercel dev] test cleanUrls and trailingSlash serve correct content',
-  testFixtureStdio('test-clean-urls-trailing-slash', async (testPath: any) => {
-    await testPath(200, '/', 'Index Page');
-    await testPath(200, '/about/', 'About Page');
-    await testPath(200, '/sub/', 'Sub Index Page');
-    await testPath(200, '/sub/another/', 'Sub Another Page');
-    await testPath(200, '/style.css', 'body { color: green }');
-    //TODO: fix this test so that location is `/` instead of `//`
-    //await testPath(308, '/index.html', 'Redirecting to / (308)', { Location: '/' });
-    await testPath(308, '/about.html', 'Redirecting to /about/ (308)', {
-      Location: '/about/',
-    });
-    await testPath(308, '/sub/index.html', 'Redirecting to /sub/ (308)', {
-      Location: '/sub/',
-    });
-    await testPath(
-      308,
-      '/sub/another.html',
-      'Redirecting to /sub/another/ (308)',
-      {
-        Location: '/sub/another/',
-      }
-    );
-  })
-);
-
-test(
-  '[vercel dev] test cors headers work with OPTIONS',
-  testFixtureStdio('test-cors-routes', async (testPath: any) => {
-    const headers = {
-      'Access-Control-Allow-Origin': '*',
-      'Access-Control-Allow-Headers':
-        'Content-Type, Authorization, Accept, Content-Length, Origin, User-Agent',
-      'Access-Control-Allow-Methods':
-        'GET, POST, OPTIONS, HEAD, PATCH, PUT, DELETE',
-    };
-    await testPath(200, '/', 'status api', headers, { method: 'GET' });
-    await testPath(200, '/', 'status api', headers, { method: 'POST' });
-    await testPath(200, '/api/status.js', 'status api', headers, {
-      method: 'GET',
-    });
-    await testPath(200, '/api/status.js', 'status api', headers, {
-      method: 'POST',
-    });
-    await testPath(204, '/', '', headers, { method: 'OPTIONS' });
-    await testPath(204, '/api/status.js', '', headers, { method: 'OPTIONS' });
-  })
-);
-
-test(
-  '[vercel dev] test trailingSlash true serve correct content',
-  testFixtureStdio('test-trailing-slash', async (testPath: any) => {
-    await testPath(200, '/', 'Index Page');
-    await testPath(200, '/index.html', 'Index Page');
-    await testPath(200, '/about.html', 'About Page');
-    await testPath(200, '/sub/', 'Sub Index Page');
-    await testPath(200, '/sub/index.html', 'Sub Index Page');
-    await testPath(200, '/sub/another.html', 'Sub Another Page');
-    await testPath(200, '/style.css', 'body { color: green }');
-    await testPath(308, '/about.html/', 'Redirecting to /about.html (308)', {
-      Location: '/about.html',
-    });
-    await testPath(308, '/style.css/', 'Redirecting to /style.css (308)', {
-      Location: '/style.css',
-    });
-    await testPath(308, '/sub', 'Redirecting to /sub/ (308)', {
-      Location: '/sub/',
-    });
-  })
-);
-
-test(
-  '[vercel dev] should serve custom 404 when `trailingSlash: true`',
-  testFixtureStdio('test-trailing-slash-custom-404', async (testPath: any) => {
-    await testPath(200, '/', 'This is the home page');
-    await testPath(200, '/about.html', 'The about page');
-    await testPath(200, '/contact/', 'Contact Subdirectory');
-    await testPath(404, '/nothing/', 'Custom 404 Page');
-  })
-);
-
-test(
-  '[vercel dev] test trailingSlash false serve correct content',
-  testFixtureStdio('test-trailing-slash-false', async (testPath: any) => {
-    await testPath(200, '/', 'Index Page');
-    await testPath(200, '/index.html', 'Index Page');
-    await testPath(200, '/about.html', 'About Page');
-    await testPath(200, '/sub', 'Sub Index Page');
-    await testPath(200, '/sub/index.html', 'Sub Index Page');
-    await testPath(200, '/sub/another.html', 'Sub Another Page');
-    await testPath(200, '/style.css', 'body { color: green }');
-    await testPath(308, '/about.html/', 'Redirecting to /about.html (308)', {
-      Location: '/about.html',
-    });
-    await testPath(308, '/sub/', 'Redirecting to /sub (308)', {
-      Location: '/sub',
-    });
-    await testPath(
-      308,
-      '/sub/another.html/',
-      'Redirecting to /sub/another.html (308)',
-      {
-        Location: '/sub/another.html',
-      }
-    );
-  })
-);
-
-test(
-  '[vercel dev] throw when invalid builder routes detected',
-  testFixtureStdio(
-    'invalid-builder-routes',
-    async (testPath: any) => {
-      await testPath(
-        500,
-        '/',
-        /Route at index 0 has invalid `src` regular expression/m
-      );
-    },
-    { skipDeploy: true }
-  )
-);
-
-test(
-  '[vercel dev] support legacy `@now` scope runtimes',
-  testFixtureStdio('legacy-now-runtime', async (testPath: any) => {
-    await testPath(200, '/', /A simple deployment with the Vercel API!/m);
-  })
-);
-
-test(
-  '[vercel dev] 00-list-directory',
-  testFixtureStdio(
-    '00-list-directory',
-    async (testPath: any) => {
-      await testPath(200, '/', /Files within/m);
-      await testPath(200, '/', /test[0-3]\.txt/m);
-      await testPath(200, '/', /\.well-known/m);
-      await testPath(200, '/.well-known/keybase.txt', 'proof goes here');
-    },
-    { projectSettings: { directoryListing: true } }
-  )
-);
-
-test(
-  '[vercel dev] 01-node',
-  testFixtureStdio('01-node', async (testPath: any) => {
-    await testPath(200, '/', /A simple deployment with the Vercel API!/m);
-  })
-);
-
-test(
-  '[vercel dev] add a `api/fn.ts` when `api` does not exist at startup`',
-  testFixtureStdio('no-api', async (_testPath: any, port: any) => {
-    const directory = fixture('no-api');
-    const apiDir = join(directory, 'api');
-
-    try {
-      {
-        const response = await fetch(`http://localhost:${port}/api/new-file`);
-        validateResponseHeaders(response);
-        expect(response.status).toBe(404);
-      }
-
-      const fileContents = `
-          export const config = {
-            runtime: 'edge'
-          }
-
-          export default async function edge(request, event) {
-            return new Response('from new file');
-          }
-        `;
-
-      await mkdirp(apiDir);
-      await fs.writeFile(join(apiDir, 'new-file.js'), fileContents);
-
-      // Wait until file events have been processed
-      await sleep(ms('1s'));
-
-      {
-        const response = await fetch(`http://localhost:${port}/api/new-file`);
-        validateResponseHeaders(response);
-        const body = await response.text();
-        expect(body.trim()).toBe('from new file');
-      }
-    } finally {
-      await fs.remove(apiDir);
-    }
-  })
-);

packages/cli/test/dev/integration-5.test.ts

@@ -0,0 +1,270 @@
+import { join } from 'path';
+import ms from 'ms';
+import fs, { mkdirp } from 'fs-extra';
+
+const {
+  fetch,
+  fixture,
+  sleep,
+  testFixtureStdio,
+  validateResponseHeaders,
+} = require('./utils.js');
+
+test(
+  '[vercel dev] test cleanUrls serve correct content',
+  testFixtureStdio('test-clean-urls', async (testPath: any) => {
+    await testPath(200, '/', 'Index Page');
+    await testPath(200, '/about', 'About Page');
+    await testPath(200, '/sub', 'Sub Index Page');
+    await testPath(200, '/sub/another', 'Sub Another Page');
+    await testPath(200, '/style.css', 'body { color: green }');
+    await testPath(308, '/index.html', 'Redirecting to / (308)', {
+      Location: '/',
+    });
+    await testPath(308, '/about.html', 'Redirecting to /about (308)', {
+      Location: '/about',
+    });
+    await testPath(308, '/sub/index.html', 'Redirecting to /sub (308)', {
+      Location: '/sub',
+    });
+    await testPath(
+      308,
+      '/sub/another.html',
+      'Redirecting to /sub/another (308)',
+      { Location: '/sub/another' }
+    );
+  })
+);
+
+test(
+  '[vercel dev] test cleanUrls serve correct content when using `outputDirectory`',
+  testFixtureStdio(
+    'test-clean-urls-with-output-directory',
+    async (testPath: any) => {
+      await testPath(200, '/', 'Index Page');
+      await testPath(200, '/about', 'About Page');
+      await testPath(200, '/sub', 'Sub Index Page');
+      await testPath(200, '/sub/another', 'Sub Another Page');
+      await testPath(200, '/style.css', 'body { color: green }');
+      await testPath(308, '/index.html', 'Redirecting to / (308)', {
+        Location: '/',
+      });
+      await testPath(308, '/about.html', 'Redirecting to /about (308)', {
+        Location: '/about',
+      });
+      await testPath(308, '/sub/index.html', 'Redirecting to /sub (308)', {
+        Location: '/sub',
+      });
+      await testPath(
+        308,
+        '/sub/another.html',
+        'Redirecting to /sub/another (308)',
+        { Location: '/sub/another' }
+      );
+    }
+  )
+);
+
+test(
+  '[vercel dev] should serve custom 404 when `cleanUrls: true`',
+  testFixtureStdio('test-clean-urls-custom-404', async (testPath: any) => {
+    await testPath(200, '/', 'This is the home page');
+    await testPath(200, '/about', 'The about page');
+    await testPath(200, '/contact/me', 'Contact Me Subdirectory');
+    await testPath(404, '/nothing', 'Custom 404 Page');
+    await testPath(404, '/nothing/', 'Custom 404 Page');
+  })
+);
+
+test(
+  '[vercel dev] test cleanUrls and trailingSlash serve correct content',
+  testFixtureStdio('test-clean-urls-trailing-slash', async (testPath: any) => {
+    await testPath(200, '/', 'Index Page');
+    await testPath(200, '/about/', 'About Page');
+    await testPath(200, '/sub/', 'Sub Index Page');
+    await testPath(200, '/sub/another/', 'Sub Another Page');
+    await testPath(200, '/style.css', 'body { color: green }');
+    //TODO: fix this test so that location is `/` instead of `//`
+    //await testPath(308, '/index.html', 'Redirecting to / (308)', { Location: '/' });
+    await testPath(308, '/about.html', 'Redirecting to /about/ (308)', {
+      Location: '/about/',
+    });
+    await testPath(308, '/sub/index.html', 'Redirecting to /sub/ (308)', {
+      Location: '/sub/',
+    });
+    await testPath(
+      308,
+      '/sub/another.html',
+      'Redirecting to /sub/another/ (308)',
+      {
+        Location: '/sub/another/',
+      }
+    );
+  })
+);
+
+test(
+  '[vercel dev] test cors headers work with OPTIONS',
+  testFixtureStdio('test-cors-routes', async (testPath: any) => {
+    const headers = {
+      'Access-Control-Allow-Origin': '*',
+      'Access-Control-Allow-Headers':
+        'Content-Type, Authorization, Accept, Content-Length, Origin, User-Agent',
+      'Access-Control-Allow-Methods':
+        'GET, POST, OPTIONS, HEAD, PATCH, PUT, DELETE',
+    };
+    await testPath(200, '/', 'status api', headers, { method: 'GET' });
+    await testPath(200, '/', 'status api', headers, { method: 'POST' });
+    await testPath(200, '/api/status.js', 'status api', headers, {
+      method: 'GET',
+    });
+    await testPath(200, '/api/status.js', 'status api', headers, {
+      method: 'POST',
+    });
+    await testPath(204, '/', '', headers, { method: 'OPTIONS' });
+    await testPath(204, '/api/status.js', '', headers, { method: 'OPTIONS' });
+  })
+);
+
+test(
+  '[vercel dev] test trailingSlash true serve correct content',
+  testFixtureStdio('test-trailing-slash', async (testPath: any) => {
+    await testPath(200, '/', 'Index Page');
+    await testPath(200, '/index.html', 'Index Page');
+    await testPath(200, '/about.html', 'About Page');
+    await testPath(200, '/sub/', 'Sub Index Page');
+    await testPath(200, '/sub/index.html', 'Sub Index Page');
+    await testPath(200, '/sub/another.html', 'Sub Another Page');
+    await testPath(200, '/style.css', 'body { color: green }');
+    await testPath(308, '/about.html/', 'Redirecting to /about.html (308)', {
+      Location: '/about.html',
+    });
+    await testPath(308, '/style.css/', 'Redirecting to /style.css (308)', {
+      Location: '/style.css',
+    });
+    await testPath(308, '/sub', 'Redirecting to /sub/ (308)', {
+      Location: '/sub/',
+    });
+  })
+);
+
+test(
+  '[vercel dev] should serve custom 404 when `trailingSlash: true`',
+  testFixtureStdio('test-trailing-slash-custom-404', async (testPath: any) => {
+    await testPath(200, '/', 'This is the home page');
+    await testPath(200, '/about.html', 'The about page');
+    await testPath(200, '/contact/', 'Contact Subdirectory');
+    await testPath(404, '/nothing/', 'Custom 404 Page');
+  })
+);
+
+test(
+  '[vercel dev] test trailingSlash false serve correct content',
+  testFixtureStdio('test-trailing-slash-false', async (testPath: any) => {
+    await testPath(200, '/', 'Index Page');
+    await testPath(200, '/index.html', 'Index Page');
+    await testPath(200, '/about.html', 'About Page');
+    await testPath(200, '/sub', 'Sub Index Page');
+    await testPath(200, '/sub/index.html', 'Sub Index Page');
+    await testPath(200, '/sub/another.html', 'Sub Another Page');
+    await testPath(200, '/style.css', 'body { color: green }');
+    await testPath(308, '/about.html/', 'Redirecting to /about.html (308)', {
+      Location: '/about.html',
+    });
+    await testPath(308, '/sub/', 'Redirecting to /sub (308)', {
+      Location: '/sub',
+    });
+    await testPath(
+      308,
+      '/sub/another.html/',
+      'Redirecting to /sub/another.html (308)',
+      {
+        Location: '/sub/another.html',
+      }
+    );
+  })
+);
+
+test(
+  '[vercel dev] throw when invalid builder routes detected',
+  testFixtureStdio(
+    'invalid-builder-routes',
+    async (testPath: any) => {
+      await testPath(
+        500,
+        '/',
+        /Route at index 0 has invalid `src` regular expression/m
+      );
+    },
+    { skipDeploy: true }
+  )
+);
+
+test(
+  '[vercel dev] support legacy `@now` scope runtimes',
+  testFixtureStdio('legacy-now-runtime', async (testPath: any) => {
+    await testPath(200, '/', /A simple deployment with the Vercel API!/m);
+  })
+);
+
+test(
+  '[vercel dev] 00-list-directory',
+  testFixtureStdio(
+    '00-list-directory',
+    async (testPath: any) => {
+      await testPath(200, '/', /Files within/m);
+      await testPath(200, '/', /test[0-3]\.txt/m);
+      await testPath(200, '/', /\.well-known/m);
+      await testPath(200, '/.well-known/keybase.txt', 'proof goes here');
+    },
+    { projectSettings: { directoryListing: true } }
+  )
+);
+
+test(
+  '[vercel dev] 01-node',
+  testFixtureStdio('01-node', async (testPath: any) => {
+    await testPath(200, '/', /A simple deployment with the Vercel API!/m);
+  })
+);
+
+test(
+  '[vercel dev] add a `api/fn.ts` when `api` does not exist at startup`',
+  testFixtureStdio('no-api', async (_testPath: any, port: any) => {
+    const directory = fixture('no-api');
+    const apiDir = join(directory, 'api');
+
+    try {
+      {
+        const response = await fetch(`http://localhost:${port}/api/new-file`);
+        validateResponseHeaders(response);
+        expect(response.status).toBe(404);
+      }
+
+      const fileContents = `
+          export const config = {
+            runtime: 'edge'
+          }
+
+          export default async function edge(request, event) {
+            return new Response('from new file');
+          }
+        `;
+
+      await mkdirp(apiDir);
+      await fs.writeFile(join(apiDir, 'new-file.js'), fileContents);
+
+      // Wait until file events have been processed
+      await sleep(ms('1s'));
+
+      {
+        const response = await fetch(`http://localhost:${port}/api/new-file`);
+        validateResponseHeaders(response);
+        const body = await response.text();
+        expect(body.trim()).toBe('from new file');
+      }
+    } finally {
+      await fs.remove(apiDir);
+    }
+  })
+);

packages/client/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/client",
-  "version": "12.2.27",
+  "version": "12.3.1",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "homepage": "https://vercel.com",
@@ -43,8 +43,8 @@
     ]
   },
   "dependencies": {
-    "@vercel/build-utils": "workspace:5.7.6",
-    "@vercel/routing-utils": "workspace:2.1.4",
+    "@vercel/build-utils": "5.9.0",
+    "@vercel/routing-utils": "2.1.8",
     "@zeit/fetch": "5.2.0",
     "async-retry": "1.2.3",
     "async-sema": "3.0.0",

packages/client/src/check-deployment-status.ts

@@ -1,6 +1,6 @@
 import sleep from 'sleep-promise';
-import ms from 'ms';
 import { fetch, getApiDeploymentsUrl } from './utils';
+import { getPollingDelay } from './utils/get-polling-delay';
 import {
   isDone,
   isReady,
@@ -47,6 +47,7 @@ export async function* checkDeploymentStatus(
   // Build polling
   debug('Waiting for builds and the deployment to complete...');
   const finishedEvents = new Set();
+  const startTime = Date.now();
 
   while (true) {
     // Deployment polling
@@ -155,6 +156,8 @@ export async function* checkDeploymentStatus(
       };
     }
 
-    await sleep(ms('1.5s'));
+    const elapsed = Date.now() - startTime;
+    const duration = getPollingDelay(elapsed);
+    await sleep(duration);
   }
 }

packages/client/src/create-deployment.ts

@@ -73,7 +73,7 @@ export default function buildCreateDeployment() {
       debug(`Provided 'path' is a single file`);
     }
 
-    let { fileList } = await buildFileTree(path, clientOptions, debug);
+    const { fileList } = await buildFileTree(path, clientOptions, debug);
 
     // This is a useful warning because it prevents people
     // from getting confused about a deployment that renders 404.

packages/client/src/deploy.ts

@@ -1,4 +1,4 @@
-import { DeploymentFile } from './utils/hashes';
+import { FilesMap } from './utils/hashes';
 import { generateQueryString } from './utils/query-string';
 import { isReady, isAliasAssigned } from './utils/ready-state';
 import { checkDeploymentStatus } from './check-deployment-status';
@@ -16,7 +16,7 @@ import {
 } from './types';
 
 async function* postDeployment(
-  files: Map<string, DeploymentFile>,
+  files: FilesMap,
   clientOptions: VercelClientOptions,
   deploymentOptions: DeploymentOptions
 ): AsyncIterableIterator<{
@@ -90,7 +90,7 @@ async function* postDeployment(
 }
 
 function getDefaultName(
-  files: Map<string, DeploymentFile>,
+  files: FilesMap,
   clientOptions: VercelClientOptions
 ): string {
   const debug = createDebug(clientOptions.debug);
@@ -109,7 +109,7 @@ function getDefaultName(
 }
 
 export async function* deploy(
-  files: Map<string, DeploymentFile>,
+  files: FilesMap,
   clientOptions: VercelClientOptions,
   deploymentOptions: DeploymentOptions
 ): AsyncIterableIterator<{ type: string; payload: any }> {

packages/client/src/upload.ts

@@ -5,7 +5,7 @@ import { EventEmitter } from 'events';
 import retry from 'async-retry';
 import { Sema } from 'async-sema';
 
-import { DeploymentFile } from './utils/hashes';
+import { DeploymentFile, FilesMap } from './utils/hashes';
 import { fetch, API_FILES, createDebug } from './utils';
 import { DeploymentError } from './errors';
 import { deploy } from './deploy';
@@ -29,7 +29,7 @@ const isClientNetworkError = (err: Error) => {
 };
 
 export async function* upload(
-  files: Map<string, DeploymentFile>,
+  files: FilesMap,
   clientOptions: VercelClientOptions,
   deploymentOptions: DeploymentOptions
 ): AsyncIterableIterator<any> {
@@ -98,6 +98,10 @@ export async function* upload(
         await semaphore.acquire();
 
         const { data } = file;
+        if (typeof data === 'undefined') {
+          // Directories don't need to be uploaded
+          return;
+        }
 
         uploadProgress.bytesUploaded = 0;
 

packages/client/src/utils/get-polling-delay.ts

@@ -0,0 +1,14 @@
+import ms from 'ms';
+
+export function getPollingDelay(elapsed: number): number {
+  if (elapsed <= ms('15s')) {
+    return ms('1s');
+  }
+  if (elapsed <= ms('1m')) {
+    return ms('5s');
+  }
+  if (elapsed <= ms('5m')) {
+    return ms('15s');
+  }
+  return ms('30s');
+}

packages/client/src/utils/hashes.ts

@@ -4,10 +4,12 @@ import { Sema } from 'async-sema';
 
 export interface DeploymentFile {
   names: string[];
-  data: Buffer;
+  data?: Buffer;
   mode: number;
 }
 
+export type FilesMap = Map<string | undefined, DeploymentFile>;
+
 /**
  * Computes a hash for the given buf.
  *
@@ -23,14 +25,12 @@ export function hash(buf: Buffer): string {
  * @param map with hashed files
  * @return {object}
  */
-export const mapToObject = (
-  map: Map<string, DeploymentFile>
-): { [key: string]: DeploymentFile } => {
+export const mapToObject = (map: FilesMap): Record<string, DeploymentFile> => {
   const obj: { [key: string]: DeploymentFile } = {};
   for (const [key, value] of map) {
+    if (typeof key === 'undefined') continue;
     obj[key] = value;
   }
-
   return obj;
 };
 
@@ -43,8 +43,8 @@ export const mapToObject = (
  */
 export async function hashes(
   files: string[],
-  map = new Map<string, DeploymentFile>()
-): Promise<Map<string, DeploymentFile>> {
+  map = new Map<string | undefined, DeploymentFile>()
+): Promise<FilesMap> {
   const semaphore = new Sema(100);
 
   await Promise.all(
@@ -54,15 +54,21 @@ export async function hashes(
       const stat = await fs.lstat(name);
       const mode = stat.mode;
 
-      let data: Buffer | null = null;
-      if (stat.isSymbolicLink()) {
-        const link = await fs.readlink(name);
-        data = Buffer.from(link, 'utf8');
-      } else {
-        data = await fs.readFile(name);
+      let data: Buffer | undefined;
+      const isDirectory = stat.isDirectory();
+
+      let h: string | undefined;
+
+      if (!isDirectory) {
+        if (stat.isSymbolicLink()) {
+          const link = await fs.readlink(name);
+          data = Buffer.from(link, 'utf8');
+        } else {
+          data = await fs.readFile(name);
+        }
+        h = hash(data);
       }
 
-      const h = hash(data);
       const entry = map.get(h);
 
       if (entry) {

packages/client/src/utils/index.ts

@@ -1,4 +1,4 @@
-import { DeploymentFile } from './hashes';
+import { FilesMap } from './hashes';
 import { FetchOptions } from '@zeit/fetch';
 import { nodeFetch, zeitFetch } from './fetch';
 import { join, sep, relative } from 'path';
@@ -256,15 +256,15 @@ export const fetch = async (
 
 export interface PreparedFile {
   file: string;
-  sha: string;
-  size: number;
+  sha?: string;
+  size?: number;
   mode: number;
 }
 
 const isWin = process.platform.includes('win');
 
 export const prepareFiles = (
-  files: Map<string, DeploymentFile>,
+  files: FilesMap,
   clientOptions: VercelClientOptions
 ): PreparedFile[] => {
   const preparedFiles: PreparedFile[] = [];
@@ -286,9 +286,9 @@ export const prepareFiles = (
 
       preparedFiles.push({
         file: isWin ? fileName.replace(/\\/g, '/') : fileName,
-        size: file.data.byteLength || file.data.length,
+        size: file.data?.byteLength || file.data?.length,
         mode: file.mode,
-        sha,
+        sha: sha || undefined,
       });
     }
   }

packages/client/src/utils/readdir-recursive.ts

@@ -87,6 +87,10 @@ export default function readdir(
           if (stats.isDirectory()) {
             readdir(filePath, ignores)
               .then(function (res) {
+                if (res.length === 0) {
+                  // Empty directories get returned
+                  list.push(filePath);
+                }
                 list = list.concat(res);
                 pending -= 1;
                 if (!pending) {

packages/client/tests/unit.get-polling-delay.test.ts

@@ -0,0 +1,41 @@
+import { getPollingDelay } from '../src/utils/get-polling-delay';
+
+describe('getPollingDelay()', () => {
+  it('should return 1 second', async () => {
+    expect(getPollingDelay(0)).toBe(1000);
+    expect(getPollingDelay(1000)).toBe(1000);
+    expect(getPollingDelay(3000)).toBe(1000);
+    expect(getPollingDelay(5000)).toBe(1000);
+    expect(getPollingDelay(8000)).toBe(1000);
+    expect(getPollingDelay(9000)).toBe(1000);
+    expect(getPollingDelay(10000)).toBe(1000);
+    expect(getPollingDelay(13000)).toBe(1000);
+    expect(getPollingDelay(15000)).toBe(1000);
+  });
+
+  it('should return 5 second', async () => {
+    expect(getPollingDelay(15001)).toBe(5000);
+    expect(getPollingDelay(16000)).toBe(5000);
+    expect(getPollingDelay(23000)).toBe(5000);
+    expect(getPollingDelay(36000)).toBe(5000);
+    expect(getPollingDelay(59000)).toBe(5000);
+    expect(getPollingDelay(60000)).toBe(5000);
+  });
+
+  it('should return 15 second', async () => {
+    expect(getPollingDelay(60001)).toBe(15000);
+    expect(getPollingDelay(80000)).toBe(15000);
+    expect(getPollingDelay(100000)).toBe(15000);
+    expect(getPollingDelay(200000)).toBe(15000);
+    expect(getPollingDelay(250000)).toBe(15000);
+    expect(getPollingDelay(300000)).toBe(15000);
+  });
+
+  it('should return 30 second', async () => {
+    expect(getPollingDelay(300001)).toBe(30000);
+    expect(getPollingDelay(400000)).toBe(30000);
+    expect(getPollingDelay(1400000)).toBe(30000);
+    expect(getPollingDelay(9400000)).toBe(30000);
+    expect(getPollingDelay(99400000)).toBe(30000);
+  });
+});

packages/client/tests/unit.utils.test.ts

@@ -24,7 +24,11 @@ describe('buildFileTree()', () => {
       noop
     );
 
-    const expectedFileList = toAbsolutePaths(cwd, ['.nowignore', 'index.txt']);
+    const expectedFileList = toAbsolutePaths(cwd, [
+      '.nowignore',
+      'folder',
+      'index.txt',
+    ]);
     expect(normalizeWindowsPaths(expectedFileList).sort()).toEqual(
       normalizeWindowsPaths(fileList).sort()
     );
@@ -41,9 +45,14 @@ describe('buildFileTree()', () => {
 
   it('should include symlinked files and directories', async () => {
     const cwd = fixture('symlinks');
+
+    // Also add an empty directory to make sure it's included
+    await fs.mkdirp(join(cwd, 'empty'));
+
     const { fileList } = await buildFileTree(cwd, { isDirectory: true }, noop);
 
     const expectedFileList = toAbsolutePaths(cwd, [
+      'empty',
       'folder-link',
       'folder/text.txt',
       'index.txt',

packages/edge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/edge",
-  "version": "0.2.2",
+  "version": "0.2.6",
   "license": "MIT",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

packages/error-utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/error-utils",
-  "version": "1.0.4",
+  "version": "1.0.8",
   "description": "A collection of error utilities for vercel/vercel",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

packages/frameworks/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/frameworks",
-  "version": "1.2.0",
+  "version": "1.2.4",
   "main": "./dist/frameworks.js",
   "types": "./dist/frameworks.d.ts",
   "files": [
@@ -21,7 +21,7 @@
     "@types/js-yaml": "3.12.1",
     "@types/node": "14.18.33",
     "@types/node-fetch": "2.5.8",
-    "@vercel/routing-utils": "workspace:2.1.4",
+    "@vercel/routing-utils": "2.1.8",
     "ajv": "6.12.2",
     "typescript": "4.3.4"
   }

packages/fs-detectors/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "3.7.0",
+  "version": "3.7.5",
   "description": "Vercel filesystem detectors",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -19,9 +19,9 @@
     "test-unit": "pnpm test"
   },
   "dependencies": {
-    "@vercel/error-utils": "workspace:1.0.4",
-    "@vercel/frameworks": "workspace:1.2.0",
-    "@vercel/routing-utils": "workspace:2.1.4",
+    "@vercel/error-utils": "1.0.8",
+    "@vercel/frameworks": "1.2.4",
+    "@vercel/routing-utils": "2.1.8",
     "glob": "8.0.3",
     "js-yaml": "4.1.0",
     "json5": "2.2.2",
@@ -35,7 +35,7 @@
     "@types/minimatch": "3.0.5",
     "@types/node": "14.18.33",
     "@types/semver": "7.3.10",
-    "@vercel/build-utils": "workspace:5.7.6",
+    "@vercel/build-utils": "5.9.0",
     "typescript": "4.3.4"
   }
 }

packages/gatsby-plugin-vercel-analytics/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/gatsby-plugin-vercel-analytics",
-  "version": "1.0.2",
+  "version": "1.0.6",
   "description": "Track Core Web Vitals in Gatsby projects with Vercel Analytics.",
   "main": "index.js",
   "files": [

packages/go/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/go",
-  "version": "2.2.25",
+  "version": "2.2.30",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/go",
@@ -36,7 +36,7 @@
     "@types/node": "14.18.33",
     "@types/node-fetch": "^2.3.0",
     "@types/tar": "^4.0.0",
-    "@vercel/build-utils": "workspace:5.7.6",
+    "@vercel/build-utils": "5.9.0",
     "@vercel/ncc": "0.24.0",
     "async-retry": "1.3.1",
     "execa": "^1.0.0",

packages/hydrogen/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/hydrogen",
-  "version": "0.0.39",
+  "version": "0.0.44",
   "license": "MIT",
   "main": "./dist/index.js",
   "homepage": "https://vercel.com/docs",
@@ -21,8 +21,8 @@
   "devDependencies": {
     "@types/jest": "27.5.1",
     "@types/node": "14.18.33",
-    "@vercel/build-utils": "workspace:5.7.6",
-    "@vercel/static-config": "workspace:2.0.7",
+    "@vercel/build-utils": "5.9.0",
+    "@vercel/static-config": "2.0.11",
     "execa": "3.2.0",
     "fs-extra": "11.1.0",
     "ts-morph": "12.0.0",

packages/next/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/next",
-  "version": "3.3.10",
+  "version": "3.3.15",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/next-js",
@@ -45,9 +45,9 @@
     "@types/semver": "6.0.0",
     "@types/text-table": "0.2.1",
     "@types/webpack-sources": "3.2.0",
-    "@vercel/build-utils": "workspace:5.7.6",
+    "@vercel/build-utils": "5.9.0",
     "@vercel/nft": "0.22.5",
-    "@vercel/routing-utils": "workspace:2.1.4",
+    "@vercel/routing-utils": "2.1.8",
     "async-sema": "3.0.1",
     "buffer-crc32": "0.2.13",
     "bytes": "3.1.2",

packages/node-bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/node-bridge",
-  "version": "3.1.4",
+  "version": "3.1.9",
   "license": "MIT",
   "main": "./index.js",
   "repository": {
@@ -23,6 +23,9 @@
   "devDependencies": {
     "@types/aws-lambda": "8.10.19",
     "@types/node": "14.18.33",
+    "content-type": "1.0.4",
+    "cookie": "0.4.0",
+    "etag": "1.8.1",
     "execa": "3.2.0",
     "fs-extra": "10.0.0",
     "jsonlines": "0.1.1",

packages/node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/node",
-  "version": "2.8.7",
+  "version": "2.8.13",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/node-js",
@@ -31,9 +31,9 @@
   "dependencies": {
     "@edge-runtime/vm": "2.0.0",
     "@types/node": "14.18.33",
-    "@vercel/build-utils": "workspace:5.7.6",
-    "@vercel/node-bridge": "workspace:3.1.4",
-    "@vercel/static-config": "workspace:2.0.7",
+    "@vercel/build-utils": "5.9.0",
+    "@vercel/node-bridge": "3.1.9",
+    "@vercel/static-config": "2.0.11",
     "edge-runtime": "2.0.0",
     "esbuild": "0.14.47",
     "exit-hook": "2.2.1",

packages/python/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "3.1.35",
+  "version": "3.1.40",
   "main": "./dist/index.js",
   "license": "MIT",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -23,7 +23,7 @@
     "@types/execa": "^0.9.0",
     "@types/jest": "27.4.1",
     "@types/node": "14.18.33",
-    "@vercel/build-utils": "workspace:5.7.6",
+    "@vercel/build-utils": "5.9.0",
     "@vercel/ncc": "0.24.0",
     "execa": "^1.0.0",
     "typescript": "4.3.4"

packages/redwood/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/redwood",
-  "version": "1.0.46",
+  "version": "1.0.51",
   "main": "./dist/index.js",
   "license": "MIT",
   "homepage": "https://vercel.com/docs",
@@ -20,14 +20,14 @@
   },
   "dependencies": {
     "@vercel/nft": "0.22.5",
-    "@vercel/routing-utils": "workspace:2.1.4",
+    "@vercel/routing-utils": "2.1.8",
     "semver": "6.1.1"
   },
   "devDependencies": {
     "@types/aws-lambda": "8.10.19",
     "@types/node": "14.18.33",
     "@types/semver": "6.0.0",
-    "@vercel/build-utils": "workspace:5.7.6",
+    "@vercel/build-utils": "5.9.0",
     "execa": "3.2.0",
     "fs-extra": "11.1.0",
     "typescript": "4.3.4"

packages/remix/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/remix",
-  "version": "1.2.0",
+  "version": "1.2.5",
   "license": "MIT",
   "main": "./dist/index.js",
   "homepage": "https://vercel.com/docs",
@@ -25,7 +25,7 @@
   "devDependencies": {
     "@types/jest": "27.5.1",
     "@types/node": "14.18.33",
-    "@vercel/build-utils": "workspace:5.7.6",
+    "@vercel/build-utils": "5.9.0",
     "typescript": "4.6.4"
   }
 }

packages/routing-utils/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/routing-utils",
-  "version": "2.1.4",
+  "version": "2.1.8",
   "description": "Vercel routing utilities",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

packages/ruby/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vercel/ruby",
   "author": "Nathan Cahill <nathan@nathancahill.com>",
-  "version": "1.3.51",
+  "version": "1.3.56",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/ruby",
@@ -22,7 +22,7 @@
   "devDependencies": {
     "@types/fs-extra": "8.0.0",
     "@types/semver": "6.0.0",
-    "@vercel/build-utils": "workspace:5.7.6",
+    "@vercel/build-utils": "5.9.0",
     "@vercel/ncc": "0.24.0",
     "execa": "2.0.4",
     "fs-extra": "^7.0.1",

packages/static-build/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/static-build",
-  "version": "1.1.2",
+  "version": "1.1.7",
   "license": "MIT",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/build-step",
@@ -37,11 +37,11 @@
     "@types/node": "14.18.33",
     "@types/node-fetch": "2.5.4",
     "@types/promise-timeout": "1.3.0",
-    "@vercel/build-utils": "workspace:5.7.6",
-    "@vercel/frameworks": "workspace:1.2.0",
+    "@vercel/build-utils": "5.9.0",
+    "@vercel/frameworks": "1.2.4",
     "@vercel/ncc": "0.24.0",
-    "@vercel/routing-utils": "workspace:2.1.4",
-    "@vercel/static-config": "workspace:2.0.7",
+    "@vercel/routing-utils": "2.1.8",
+    "@vercel/static-config": "2.0.11",
     "execa": "3.2.0",
     "fs-extra": "10.0.0",
     "get-port": "5.0.0",

packages/static-config/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/static-config",
-  "version": "2.0.7",
+  "version": "2.0.11",
   "license": "MIT",
   "main": "./dist/index",
   "repository": {

pnpm-lock.yaml

@@ -7,9 +7,9 @@ importers:
       '@types/node': 14.18.33
       '@typescript-eslint/eslint-plugin': 5.21.0
       '@typescript-eslint/parser': 5.21.0
-      '@vercel/build-utils': workspace:5.7.5
+      '@vercel/build-utils': '*'
       '@vercel/ncc': 0.24.0
-      '@vercel/next': workspace:3.3.9
+      '@vercel/next': '*'
       async-retry: 1.2.3
       buffer-replace: 1.0.0
       create-svelte: 2.0.1
@@ -66,7 +66,7 @@ importers:
       '@sentry/node': 5.11.1
       '@types/node': 16.18.11
       '@types/node-fetch': 2.5.4
-      '@vercel/node': workspace:2.8.6
+      '@vercel/node': '*'
       got: 10.2.1
       node-fetch: 2.6.7
       parse-github-url: 1.0.2
@@ -198,23 +198,23 @@ importers:
       '@types/which': 1.3.2
       '@types/write-json-file': 2.2.1
       '@types/yauzl-promise': 2.1.0
-      '@vercel/build-utils': workspace:5.7.5
-      '@vercel/client': workspace:12.2.26
-      '@vercel/error-utils': workspace:1.0.3
-      '@vercel/frameworks': workspace:1.1.18
-      '@vercel/fs-detectors': workspace:3.6.2
+      '@vercel/build-utils': 5.9.0
+      '@vercel/client': 12.3.1
+      '@vercel/error-utils': 1.0.8
+      '@vercel/frameworks': 1.2.4
+      '@vercel/fs-detectors': 3.7.5
       '@vercel/fun': 1.0.4
-      '@vercel/go': workspace:2.2.24
-      '@vercel/hydrogen': workspace:0.0.38
+      '@vercel/go': 2.2.30
+      '@vercel/hydrogen': 0.0.44
       '@vercel/ncc': 0.24.0
-      '@vercel/next': workspace:3.3.9
-      '@vercel/node': workspace:2.8.6
-      '@vercel/python': workspace:3.1.34
-      '@vercel/redwood': workspace:1.0.45
-      '@vercel/remix': workspace:1.1.7
-      '@vercel/routing-utils': workspace:2.1.3
-      '@vercel/ruby': workspace:1.3.50
-      '@vercel/static-build': workspace:1.1.1
+      '@vercel/next': 3.3.15
+      '@vercel/node': 2.8.13
+      '@vercel/python': 3.1.40
+      '@vercel/redwood': 1.0.51
+      '@vercel/remix': 1.2.5
+      '@vercel/routing-utils': 2.1.8
+      '@vercel/ruby': 1.3.56
+      '@vercel/static-build': 1.1.7
       '@zeit/source-map-support': 0.6.2
       ajv: 6.12.2
       alpha-sort: 2.0.1
@@ -440,8 +440,8 @@ importers:
       '@types/node-fetch': 2.5.4
       '@types/recursive-readdir': 2.2.0
       '@types/tar-fs': 1.16.1
-      '@vercel/build-utils': workspace:5.7.5
-      '@vercel/routing-utils': workspace:2.1.3
+      '@vercel/build-utils': 5.9.0
+      '@vercel/routing-utils': 2.1.8
       '@zeit/fetch': 5.2.0
       async-retry: 1.2.3
       async-sema: 3.0.0
@@ -521,7 +521,7 @@ importers:
       '@types/js-yaml': 3.12.1
       '@types/node': 14.18.33
       '@types/node-fetch': 2.5.8
-      '@vercel/routing-utils': workspace:2.1.3
+      '@vercel/routing-utils': 2.1.8
       ajv: 6.12.2
       js-yaml: 3.13.1
       typescript: 4.3.4
@@ -545,10 +545,10 @@ importers:
       '@types/minimatch': 3.0.5
       '@types/node': 14.18.33
       '@types/semver': 7.3.10
-      '@vercel/build-utils': workspace:5.7.5
-      '@vercel/error-utils': workspace:1.0.3
-      '@vercel/frameworks': workspace:1.1.18
-      '@vercel/routing-utils': workspace:2.1.3
+      '@vercel/build-utils': 5.9.0
+      '@vercel/error-utils': 1.0.8
+      '@vercel/frameworks': 1.2.4
+      '@vercel/routing-utils': 2.1.8
       glob: 8.0.3
       js-yaml: 4.1.0
       json5: 2.2.2
@@ -592,7 +592,7 @@ importers:
       '@types/node': 14.18.33
       '@types/node-fetch': ^2.3.0
       '@types/tar': ^4.0.0
-      '@vercel/build-utils': workspace:5.7.5
+      '@vercel/build-utils': 5.9.0
       '@vercel/ncc': 0.24.0
       async-retry: 1.3.1
       execa: ^1.0.0
@@ -624,8 +624,8 @@ importers:
     specifiers:
       '@types/jest': 27.5.1
       '@types/node': 14.18.33
-      '@vercel/build-utils': workspace:5.7.5
-      '@vercel/static-config': workspace:2.0.6
+      '@vercel/build-utils': 5.9.0
+      '@vercel/static-config': 2.0.11
       execa: 3.2.0
       fs-extra: 11.1.0
       ts-morph: 12.0.0
@@ -655,9 +655,9 @@ importers:
       '@types/semver': 6.0.0
       '@types/text-table': 0.2.1
       '@types/webpack-sources': 3.2.0
-      '@vercel/build-utils': workspace:5.7.5
+      '@vercel/build-utils': 5.9.0
       '@vercel/nft': 0.22.5
-      '@vercel/routing-utils': workspace:2.1.3
+      '@vercel/routing-utils': 2.1.8
       async-sema: 3.0.1
       buffer-crc32: 0.2.13
       bytes: 3.1.2
@@ -734,11 +734,11 @@ importers:
       '@types/node': 14.18.33
       '@types/node-fetch': ^2.6.1
       '@types/test-listen': 1.1.0
-      '@vercel/build-utils': workspace:5.7.5
+      '@vercel/build-utils': 5.9.0
       '@vercel/ncc': 0.24.0
       '@vercel/nft': 0.22.5
-      '@vercel/node-bridge': workspace:3.1.3
-      '@vercel/static-config': workspace:2.0.6
+      '@vercel/node-bridge': 3.1.9
+      '@vercel/static-config': 2.0.11
       content-type: 1.0.4
       cookie: 0.4.0
       edge-runtime: 2.0.0
@@ -793,6 +793,9 @@ importers:
     specifiers:
       '@types/aws-lambda': 8.10.19
       '@types/node': 14.18.33
+      content-type: 1.0.4
+      cookie: 0.4.0
+      etag: 1.8.1
       execa: 3.2.0
       fs-extra: 10.0.0
       jsonlines: 0.1.1
@@ -801,6 +804,9 @@ importers:
     devDependencies:
       '@types/aws-lambda': 8.10.19
       '@types/node': 14.18.33
+      content-type: 1.0.4
+      cookie: 0.4.0
+      etag: 1.8.1
       execa: 3.2.0
       fs-extra: 10.0.0
       jsonlines: 0.1.1
@@ -812,7 +818,7 @@ importers:
       '@types/execa': ^0.9.0
       '@types/jest': 27.4.1
       '@types/node': 14.18.33
-      '@vercel/build-utils': workspace:5.7.5
+      '@vercel/build-utils': 5.9.0
       '@vercel/ncc': 0.24.0
       execa: ^1.0.0
       typescript: 4.3.4
@@ -830,9 +836,9 @@ importers:
       '@types/aws-lambda': 8.10.19
       '@types/node': 14.18.33
       '@types/semver': 6.0.0
-      '@vercel/build-utils': workspace:5.7.5
+      '@vercel/build-utils': 5.9.0
       '@vercel/nft': 0.22.5
-      '@vercel/routing-utils': workspace:2.1.3
+      '@vercel/routing-utils': 2.1.8
       execa: 3.2.0
       fs-extra: 11.1.0
       semver: 6.1.1
@@ -854,7 +860,7 @@ importers:
     specifiers:
       '@types/jest': 27.5.1
       '@types/node': 14.18.33
-      '@vercel/build-utils': workspace:5.7.5
+      '@vercel/build-utils': 5.9.0
       '@vercel/nft': 0.22.5
       typescript: 4.6.4
     dependencies:
@@ -885,7 +891,7 @@ importers:
     specifiers:
       '@types/fs-extra': 8.0.0
       '@types/semver': 6.0.0
-      '@vercel/build-utils': workspace:5.7.5
+      '@vercel/build-utils': 5.9.0
       '@vercel/ncc': 0.24.0
       execa: 2.0.4
       fs-extra: ^7.0.1
@@ -911,11 +917,11 @@ importers:
       '@types/node': 14.18.33
       '@types/node-fetch': 2.5.4
       '@types/promise-timeout': 1.3.0
-      '@vercel/build-utils': workspace:5.7.5
-      '@vercel/frameworks': workspace:1.1.18
+      '@vercel/build-utils': 5.9.0
+      '@vercel/frameworks': 1.2.4
       '@vercel/ncc': 0.24.0
-      '@vercel/routing-utils': workspace:2.1.3
-      '@vercel/static-config': workspace:2.0.6
+      '@vercel/routing-utils': 2.1.8
+      '@vercel/static-config': 2.0.11
       execa: 3.2.0
       fs-extra: 10.0.0
       get-port: 5.0.0

utils/changelog.js

@@ -105,7 +105,7 @@ async function main() {
   const pub = Array.from(pkgs).join(',');
   console.log('To publish a stable release, execute the following:');
   console.log(
-    `\nnpx lerna version --message "Publish Stable" --exact --force-publish=${pub}\n`
+    `\npnpx lerna version --message "Publish Stable" --exact --no-private --force-publish=${pub}\n`
   );
 }
 

utils/publish.sh

@@ -29,9 +29,6 @@ else
   echo "Publishing stable release"
 fi
 
-# Sometimes this is a false alarm and blocks publish
-git checkout pnpm-lock.yaml
-
 pnpm run lerna publish from-git $dist_tag --no-verify-access --yes
 
 # always update canary dist-tag as we no longer publish canary versions separate