@vercel/go 2.4.4 → 2.5.1

package/dist/index.js

@@ -5556,6 +5556,979 @@ function patch (fs) {
 }
 
 
+/***/ }),
+
+/***/ 3016:
+/***/ ((module) => {
+
+"use strict";
+
+
+module.exports = clone
+
+var getPrototypeOf = Object.getPrototypeOf || function (obj) {
+  return obj.__proto__
+}
+
+function clone (obj) {
+  if (obj === null || typeof obj !== 'object')
+    return obj
+
+  if (obj instanceof Object)
+    var copy = { __proto__: getPrototypeOf(obj) }
+  else
+    var copy = Object.create(null)
+
+  Object.getOwnPropertyNames(obj).forEach(function (key) {
+    Object.defineProperty(copy, key, Object.getOwnPropertyDescriptor(obj, key))
+  })
+
+  return copy
+}
+
+
+/***/ }),
+
+/***/ 7156:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var fs = __webpack_require__(5747)
+var polyfills = __webpack_require__(4692)
+var legacy = __webpack_require__(6465)
+var clone = __webpack_require__(3016)
+
+var util = __webpack_require__(1669)
+
+/* istanbul ignore next - node 0.x polyfill */
+var gracefulQueue
+var previousSymbol
+
+/* istanbul ignore else - node 0.x polyfill */
+if (typeof Symbol === 'function' && typeof Symbol.for === 'function') {
+  gracefulQueue = Symbol.for('graceful-fs.queue')
+  // This is used in testing by future versions
+  previousSymbol = Symbol.for('graceful-fs.previous')
+} else {
+  gracefulQueue = '___graceful-fs.queue'
+  previousSymbol = '___graceful-fs.previous'
+}
+
+function noop () {}
+
+function publishQueue(context, queue) {
+  Object.defineProperty(context, gracefulQueue, {
+    get: function() {
+      return queue
+    }
+  })
+}
+
+var debug = noop
+if (util.debuglog)
+  debug = util.debuglog('gfs4')
+else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ''))
+  debug = function() {
+    var m = util.format.apply(util, arguments)
+    m = 'GFS4: ' + m.split(/\n/).join('\nGFS4: ')
+    console.error(m)
+  }
+
+// Once time initialization
+if (!fs[gracefulQueue]) {
+  // This queue can be shared by multiple loaded instances
+  var queue = global[gracefulQueue] || []
+  publishQueue(fs, queue)
+
+  // Patch fs.close/closeSync to shared queue version, because we need
+  // to retry() whenever a close happens *anywhere* in the program.
+  // This is essential when multiple graceful-fs instances are
+  // in play at the same time.
+  fs.close = (function (fs$close) {
+    function close (fd, cb) {
+      return fs$close.call(fs, fd, function (err) {
+        // This function uses the graceful-fs shared queue
+        if (!err) {
+          resetQueue()
+        }
+
+        if (typeof cb === 'function')
+          cb.apply(this, arguments)
+      })
+    }
+
+    Object.defineProperty(close, previousSymbol, {
+      value: fs$close
+    })
+    return close
+  })(fs.close)
+
+  fs.closeSync = (function (fs$closeSync) {
+    function closeSync (fd) {
+      // This function uses the graceful-fs shared queue
+      fs$closeSync.apply(fs, arguments)
+      resetQueue()
+    }
+
+    Object.defineProperty(closeSync, previousSymbol, {
+      value: fs$closeSync
+    })
+    return closeSync
+  })(fs.closeSync)
+
+  if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || '')) {
+    process.on('exit', function() {
+      debug(fs[gracefulQueue])
+      __webpack_require__(2357).equal(fs[gracefulQueue].length, 0)
+    })
+  }
+}
+
+if (!global[gracefulQueue]) {
+  publishQueue(global, fs[gracefulQueue]);
+}
+
+module.exports = patch(clone(fs))
+if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs.__patched) {
+    module.exports = patch(fs)
+    fs.__patched = true;
+}
+
+function patch (fs) {
+  // Everything that references the open() function needs to be in here
+  polyfills(fs)
+  fs.gracefulify = patch
+
+  fs.createReadStream = createReadStream
+  fs.createWriteStream = createWriteStream
+  var fs$readFile = fs.readFile
+  fs.readFile = readFile
+  function readFile (path, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null
+
+    return go$readFile(path, options, cb)
+
+    function go$readFile (path, options, cb, startTime) {
+      return fs$readFile(path, options, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$readFile, [path, options, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
+
+  var fs$writeFile = fs.writeFile
+  fs.writeFile = writeFile
+  function writeFile (path, data, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null
+
+    return go$writeFile(path, data, options, cb)
+
+    function go$writeFile (path, data, options, cb, startTime) {
+      return fs$writeFile(path, data, options, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$writeFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
+
+  var fs$appendFile = fs.appendFile
+  if (fs$appendFile)
+    fs.appendFile = appendFile
+  function appendFile (path, data, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null
+
+    return go$appendFile(path, data, options, cb)
+
+    function go$appendFile (path, data, options, cb, startTime) {
+      return fs$appendFile(path, data, options, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$appendFile, [path, data, options, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
+
+  var fs$copyFile = fs.copyFile
+  if (fs$copyFile)
+    fs.copyFile = copyFile
+  function copyFile (src, dest, flags, cb) {
+    if (typeof flags === 'function') {
+      cb = flags
+      flags = 0
+    }
+    return go$copyFile(src, dest, flags, cb)
+
+    function go$copyFile (src, dest, flags, cb, startTime) {
+      return fs$copyFile(src, dest, flags, function (err) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$copyFile, [src, dest, flags, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
+
+  var fs$readdir = fs.readdir
+  fs.readdir = readdir
+  var noReaddirOptionVersions = /^v[0-5]\./
+  function readdir (path, options, cb) {
+    if (typeof options === 'function')
+      cb = options, options = null
+
+    var go$readdir = noReaddirOptionVersions.test(process.version)
+      ? function go$readdir (path, options, cb, startTime) {
+        return fs$readdir(path, fs$readdirCallback(
+          path, options, cb, startTime
+        ))
+      }
+      : function go$readdir (path, options, cb, startTime) {
+        return fs$readdir(path, options, fs$readdirCallback(
+          path, options, cb, startTime
+        ))
+      }
+
+    return go$readdir(path, options, cb)
+
+    function fs$readdirCallback (path, options, cb, startTime) {
+      return function (err, files) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([
+            go$readdir,
+            [path, options, cb],
+            err,
+            startTime || Date.now(),
+            Date.now()
+          ])
+        else {
+          if (files && files.sort)
+            files.sort()
+
+          if (typeof cb === 'function')
+            cb.call(this, err, files)
+        }
+      }
+    }
+  }
+
+  if (process.version.substr(0, 4) === 'v0.8') {
+    var legStreams = legacy(fs)
+    ReadStream = legStreams.ReadStream
+    WriteStream = legStreams.WriteStream
+  }
+
+  var fs$ReadStream = fs.ReadStream
+  if (fs$ReadStream) {
+    ReadStream.prototype = Object.create(fs$ReadStream.prototype)
+    ReadStream.prototype.open = ReadStream$open
+  }
+
+  var fs$WriteStream = fs.WriteStream
+  if (fs$WriteStream) {
+    WriteStream.prototype = Object.create(fs$WriteStream.prototype)
+    WriteStream.prototype.open = WriteStream$open
+  }
+
+  Object.defineProperty(fs, 'ReadStream', {
+    get: function () {
+      return ReadStream
+    },
+    set: function (val) {
+      ReadStream = val
+    },
+    enumerable: true,
+    configurable: true
+  })
+  Object.defineProperty(fs, 'WriteStream', {
+    get: function () {
+      return WriteStream
+    },
+    set: function (val) {
+      WriteStream = val
+    },
+    enumerable: true,
+    configurable: true
+  })
+
+  // legacy names
+  var FileReadStream = ReadStream
+  Object.defineProperty(fs, 'FileReadStream', {
+    get: function () {
+      return FileReadStream
+    },
+    set: function (val) {
+      FileReadStream = val
+    },
+    enumerable: true,
+    configurable: true
+  })
+  var FileWriteStream = WriteStream
+  Object.defineProperty(fs, 'FileWriteStream', {
+    get: function () {
+      return FileWriteStream
+    },
+    set: function (val) {
+      FileWriteStream = val
+    },
+    enumerable: true,
+    configurable: true
+  })
+
+  function ReadStream (path, options) {
+    if (this instanceof ReadStream)
+      return fs$ReadStream.apply(this, arguments), this
+    else
+      return ReadStream.apply(Object.create(ReadStream.prototype), arguments)
+  }
+
+  function ReadStream$open () {
+    var that = this
+    open(that.path, that.flags, that.mode, function (err, fd) {
+      if (err) {
+        if (that.autoClose)
+          that.destroy()
+
+        that.emit('error', err)
+      } else {
+        that.fd = fd
+        that.emit('open', fd)
+        that.read()
+      }
+    })
+  }
+
+  function WriteStream (path, options) {
+    if (this instanceof WriteStream)
+      return fs$WriteStream.apply(this, arguments), this
+    else
+      return WriteStream.apply(Object.create(WriteStream.prototype), arguments)
+  }
+
+  function WriteStream$open () {
+    var that = this
+    open(that.path, that.flags, that.mode, function (err, fd) {
+      if (err) {
+        that.destroy()
+        that.emit('error', err)
+      } else {
+        that.fd = fd
+        that.emit('open', fd)
+      }
+    })
+  }
+
+  function createReadStream (path, options) {
+    return new fs.ReadStream(path, options)
+  }
+
+  function createWriteStream (path, options) {
+    return new fs.WriteStream(path, options)
+  }
+
+  var fs$open = fs.open
+  fs.open = open
+  function open (path, flags, mode, cb) {
+    if (typeof mode === 'function')
+      cb = mode, mode = null
+
+    return go$open(path, flags, mode, cb)
+
+    function go$open (path, flags, mode, cb, startTime) {
+      return fs$open(path, flags, mode, function (err, fd) {
+        if (err && (err.code === 'EMFILE' || err.code === 'ENFILE'))
+          enqueue([go$open, [path, flags, mode, cb], err, startTime || Date.now(), Date.now()])
+        else {
+          if (typeof cb === 'function')
+            cb.apply(this, arguments)
+        }
+      })
+    }
+  }
+
+  return fs
+}
+
+function enqueue (elem) {
+  debug('ENQUEUE', elem[0].name, elem[1])
+  fs[gracefulQueue].push(elem)
+  retry()
+}
+
+// keep track of the timeout between retry() calls
+var retryTimer
+
+// reset the startTime and lastTime to now
+// this resets the start of the 60 second overall timeout as well as the
+// delay between attempts so that we'll retry these jobs sooner
+function resetQueue () {
+  var now = Date.now()
+  for (var i = 0; i < fs[gracefulQueue].length; ++i) {
+    // entries that are only a length of 2 are from an older version, don't
+    // bother modifying those since they'll be retried anyway.
+    if (fs[gracefulQueue][i].length > 2) {
+      fs[gracefulQueue][i][3] = now // startTime
+      fs[gracefulQueue][i][4] = now // lastTime
+    }
+  }
+  // call retry to make sure we're actively processing the queue
+  retry()
+}
+
+function retry () {
+  // clear the timer and remove it to help prevent unintended concurrency
+  clearTimeout(retryTimer)
+  retryTimer = undefined
+
+  if (fs[gracefulQueue].length === 0)
+    return
+
+  var elem = fs[gracefulQueue].shift()
+  var fn = elem[0]
+  var args = elem[1]
+  // these items may be unset if they were added by an older graceful-fs
+  var err = elem[2]
+  var startTime = elem[3]
+  var lastTime = elem[4]
+
+  // if we don't have a startTime we have no way of knowing if we've waited
+  // long enough, so go ahead and retry this item now
+  if (startTime === undefined) {
+    debug('RETRY', fn.name, args)
+    fn.apply(null, args)
+  } else if (Date.now() - startTime >= 60000) {
+    // it's been more than 60 seconds total, bail now
+    debug('TIMEOUT', fn.name, args)
+    var cb = args.pop()
+    if (typeof cb === 'function')
+      cb.call(null, err)
+  } else {
+    // the amount of time between the last attempt and right now
+    var sinceAttempt = Date.now() - lastTime
+    // the amount of time between when we first tried, and when we last tried
+    // rounded up to at least 1
+    var sinceStart = Math.max(lastTime - startTime, 1)
+    // backoff. wait longer than the total time we've been retrying, but only
+    // up to a maximum of 100ms
+    var desiredDelay = Math.min(sinceStart * 1.2, 100)
+    // it's been long enough since the last retry, do it again
+    if (sinceAttempt >= desiredDelay) {
+      debug('RETRY', fn.name, args)
+      fn.apply(null, args.concat([startTime]))
+    } else {
+      // if we can't do this job yet, push it to the end of the queue
+      // and let the next iteration check again
+      fs[gracefulQueue].push(elem)
+    }
+  }
+
+  // schedule our next run if one isn't already scheduled
+  if (retryTimer === undefined) {
+    retryTimer = setTimeout(retry, 0)
+  }
+}
+
+
+/***/ }),
+
+/***/ 6465:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var Stream = __webpack_require__(2413).Stream
+
+module.exports = legacy
+
+function legacy (fs) {
+  return {
+    ReadStream: ReadStream,
+    WriteStream: WriteStream
+  }
+
+  function ReadStream (path, options) {
+    if (!(this instanceof ReadStream)) return new ReadStream(path, options);
+
+    Stream.call(this);
+
+    var self = this;
+
+    this.path = path;
+    this.fd = null;
+    this.readable = true;
+    this.paused = false;
+
+    this.flags = 'r';
+    this.mode = 438; /*=0666*/
+    this.bufferSize = 64 * 1024;
+
+    options = options || {};
+
+    // Mixin options into this
+    var keys = Object.keys(options);
+    for (var index = 0, length = keys.length; index < length; index++) {
+      var key = keys[index];
+      this[key] = options[key];
+    }
+
+    if (this.encoding) this.setEncoding(this.encoding);
+
+    if (this.start !== undefined) {
+      if ('number' !== typeof this.start) {
+        throw TypeError('start must be a Number');
+      }
+      if (this.end === undefined) {
+        this.end = Infinity;
+      } else if ('number' !== typeof this.end) {
+        throw TypeError('end must be a Number');
+      }
+
+      if (this.start > this.end) {
+        throw new Error('start must be <= end');
+      }
+
+      this.pos = this.start;
+    }
+
+    if (this.fd !== null) {
+      process.nextTick(function() {
+        self._read();
+      });
+      return;
+    }
+
+    fs.open(this.path, this.flags, this.mode, function (err, fd) {
+      if (err) {
+        self.emit('error', err);
+        self.readable = false;
+        return;
+      }
+
+      self.fd = fd;
+      self.emit('open', fd);
+      self._read();
+    })
+  }
+
+  function WriteStream (path, options) {
+    if (!(this instanceof WriteStream)) return new WriteStream(path, options);
+
+    Stream.call(this);
+
+    this.path = path;
+    this.fd = null;
+    this.writable = true;
+
+    this.flags = 'w';
+    this.encoding = 'binary';
+    this.mode = 438; /*=0666*/
+    this.bytesWritten = 0;
+
+    options = options || {};
+
+    // Mixin options into this
+    var keys = Object.keys(options);
+    for (var index = 0, length = keys.length; index < length; index++) {
+      var key = keys[index];
+      this[key] = options[key];
+    }
+
+    if (this.start !== undefined) {
+      if ('number' !== typeof this.start) {
+        throw TypeError('start must be a Number');
+      }
+      if (this.start < 0) {
+        throw new Error('start must be >= zero');
+      }
+
+      this.pos = this.start;
+    }
+
+    this.busy = false;
+    this._queue = [];
+
+    if (this.fd === null) {
+      this._open = fs.open;
+      this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
+      this.flush();
+    }
+  }
+}
+
+
+/***/ }),
+
+/***/ 4692:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+var constants = __webpack_require__(7619)
+
+var origCwd = process.cwd
+var cwd = null
+
+var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform
+
+process.cwd = function() {
+  if (!cwd)
+    cwd = origCwd.call(process)
+  return cwd
+}
+try {
+  process.cwd()
+} catch (er) {}
+
+// This check is needed until node.js 12 is required
+if (typeof process.chdir === 'function') {
+  var chdir = process.chdir
+  process.chdir = function (d) {
+    cwd = null
+    chdir.call(process, d)
+  }
+  if (Object.setPrototypeOf) Object.setPrototypeOf(process.chdir, chdir)
+}
+
+module.exports = patch
+
+function patch (fs) {
+  // (re-)implement some things that are known busted or missing.
+
+  // lchmod, broken prior to 0.6.2
+  // back-port the fix here.
+  if (constants.hasOwnProperty('O_SYMLINK') &&
+      process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+    patchLchmod(fs)
+  }
+
+  // lutimes implementation, or no-op
+  if (!fs.lutimes) {
+    patchLutimes(fs)
+  }
+
+  // https://github.com/isaacs/node-graceful-fs/issues/4
+  // Chown should not fail on einval or eperm if non-root.
+  // It should not fail on enosys ever, as this just indicates
+  // that a fs doesn't support the intended operation.
+
+  fs.chown = chownFix(fs.chown)
+  fs.fchown = chownFix(fs.fchown)
+  fs.lchown = chownFix(fs.lchown)
+
+  fs.chmod = chmodFix(fs.chmod)
+  fs.fchmod = chmodFix(fs.fchmod)
+  fs.lchmod = chmodFix(fs.lchmod)
+
+  fs.chownSync = chownFixSync(fs.chownSync)
+  fs.fchownSync = chownFixSync(fs.fchownSync)
+  fs.lchownSync = chownFixSync(fs.lchownSync)
+
+  fs.chmodSync = chmodFixSync(fs.chmodSync)
+  fs.fchmodSync = chmodFixSync(fs.fchmodSync)
+  fs.lchmodSync = chmodFixSync(fs.lchmodSync)
+
+  fs.stat = statFix(fs.stat)
+  fs.fstat = statFix(fs.fstat)
+  fs.lstat = statFix(fs.lstat)
+
+  fs.statSync = statFixSync(fs.statSync)
+  fs.fstatSync = statFixSync(fs.fstatSync)
+  fs.lstatSync = statFixSync(fs.lstatSync)
+
+  // if lchmod/lchown do not exist, then make them no-ops
+  if (fs.chmod && !fs.lchmod) {
+    fs.lchmod = function (path, mode, cb) {
+      if (cb) process.nextTick(cb)
+    }
+    fs.lchmodSync = function () {}
+  }
+  if (fs.chown && !fs.lchown) {
+    fs.lchown = function (path, uid, gid, cb) {
+      if (cb) process.nextTick(cb)
+    }
+    fs.lchownSync = function () {}
+  }
+
+  // on Windows, A/V software can lock the directory, causing this
+  // to fail with an EACCES or EPERM if the directory contains newly
+  // created files.  Try again on failure, for up to 60 seconds.
+
+  // Set the timeout this long because some Windows Anti-Virus, such as Parity
+  // bit9, may lock files for up to a minute, causing npm package install
+  // failures. Also, take care to yield the scheduler. Windows scheduling gives
+  // CPU to a busy looping process, which can cause the program causing the lock
+  // contention to be starved of CPU by node, so the contention doesn't resolve.
+  if (platform === "win32") {
+    fs.rename = typeof fs.rename !== 'function' ? fs.rename
+    : (function (fs$rename) {
+      function rename (from, to, cb) {
+        var start = Date.now()
+        var backoff = 0;
+        fs$rename(from, to, function CB (er) {
+          if (er
+              && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY")
+              && Date.now() - start < 60000) {
+            setTimeout(function() {
+              fs.stat(to, function (stater, st) {
+                if (stater && stater.code === "ENOENT")
+                  fs$rename(from, to, CB);
+                else
+                  cb(er)
+              })
+            }, backoff)
+            if (backoff < 100)
+              backoff += 10;
+            return;
+          }
+          if (cb) cb(er)
+        })
+      }
+      if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename)
+      return rename
+    })(fs.rename)
+  }
+
+  // if read() returns EAGAIN, then just try it again.
+  fs.read = typeof fs.read !== 'function' ? fs.read
+  : (function (fs$read) {
+    function read (fd, buffer, offset, length, position, callback_) {
+      var callback
+      if (callback_ && typeof callback_ === 'function') {
+        var eagCounter = 0
+        callback = function (er, _, __) {
+          if (er && er.code === 'EAGAIN' && eagCounter < 10) {
+            eagCounter ++
+            return fs$read.call(fs, fd, buffer, offset, length, position, callback)
+          }
+          callback_.apply(this, arguments)
+        }
+      }
+      return fs$read.call(fs, fd, buffer, offset, length, position, callback)
+    }
+
+    // This ensures `util.promisify` works as it does for native `fs.read`.
+    if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read)
+    return read
+  })(fs.read)
+
+  fs.readSync = typeof fs.readSync !== 'function' ? fs.readSync
+  : (function (fs$readSync) { return function (fd, buffer, offset, length, position) {
+    var eagCounter = 0
+    while (true) {
+      try {
+        return fs$readSync.call(fs, fd, buffer, offset, length, position)
+      } catch (er) {
+        if (er.code === 'EAGAIN' && eagCounter < 10) {
+          eagCounter ++
+          continue
+        }
+        throw er
+      }
+    }
+  }})(fs.readSync)
+
+  function patchLchmod (fs) {
+    fs.lchmod = function (path, mode, callback) {
+      fs.open( path
+             , constants.O_WRONLY | constants.O_SYMLINK
+             , mode
+             , function (err, fd) {
+        if (err) {
+          if (callback) callback(err)
+          return
+        }
+        // prefer to return the chmod error, if one occurs,
+        // but still try to close, and report closing errors if they occur.
+        fs.fchmod(fd, mode, function (err) {
+          fs.close(fd, function(err2) {
+            if (callback) callback(err || err2)
+          })
+        })
+      })
+    }
+
+    fs.lchmodSync = function (path, mode) {
+      var fd = fs.openSync(path, constants.O_WRONLY | constants.O_SYMLINK, mode)
+
+      // prefer to return the chmod error, if one occurs,
+      // but still try to close, and report closing errors if they occur.
+      var threw = true
+      var ret
+      try {
+        ret = fs.fchmodSync(fd, mode)
+        threw = false
+      } finally {
+        if (threw) {
+          try {
+            fs.closeSync(fd)
+          } catch (er) {}
+        } else {
+          fs.closeSync(fd)
+        }
+      }
+      return ret
+    }
+  }
+
+  function patchLutimes (fs) {
+    if (constants.hasOwnProperty("O_SYMLINK") && fs.futimes) {
+      fs.lutimes = function (path, at, mt, cb) {
+        fs.open(path, constants.O_SYMLINK, function (er, fd) {
+          if (er) {
+            if (cb) cb(er)
+            return
+          }
+          fs.futimes(fd, at, mt, function (er) {
+            fs.close(fd, function (er2) {
+              if (cb) cb(er || er2)
+            })
+          })
+        })
+      }
+
+      fs.lutimesSync = function (path, at, mt) {
+        var fd = fs.openSync(path, constants.O_SYMLINK)
+        var ret
+        var threw = true
+        try {
+          ret = fs.futimesSync(fd, at, mt)
+          threw = false
+        } finally {
+          if (threw) {
+            try {
+              fs.closeSync(fd)
+            } catch (er) {}
+          } else {
+            fs.closeSync(fd)
+          }
+        }
+        return ret
+      }
+
+    } else if (fs.futimes) {
+      fs.lutimes = function (_a, _b, _c, cb) { if (cb) process.nextTick(cb) }
+      fs.lutimesSync = function () {}
+    }
+  }
+
+  function chmodFix (orig) {
+    if (!orig) return orig
+    return function (target, mode, cb) {
+      return orig.call(fs, target, mode, function (er) {
+        if (chownErOk(er)) er = null
+        if (cb) cb.apply(this, arguments)
+      })
+    }
+  }
+
+  function chmodFixSync (orig) {
+    if (!orig) return orig
+    return function (target, mode) {
+      try {
+        return orig.call(fs, target, mode)
+      } catch (er) {
+        if (!chownErOk(er)) throw er
+      }
+    }
+  }
+
+
+  function chownFix (orig) {
+    if (!orig) return orig
+    return function (target, uid, gid, cb) {
+      return orig.call(fs, target, uid, gid, function (er) {
+        if (chownErOk(er)) er = null
+        if (cb) cb.apply(this, arguments)
+      })
+    }
+  }
+
+  function chownFixSync (orig) {
+    if (!orig) return orig
+    return function (target, uid, gid) {
+      try {
+        return orig.call(fs, target, uid, gid)
+      } catch (er) {
+        if (!chownErOk(er)) throw er
+      }
+    }
+  }
+
+  function statFix (orig) {
+    if (!orig) return orig
+    // Older versions of Node erroneously returned signed integers for
+    // uid + gid.
+    return function (target, options, cb) {
+      if (typeof options === 'function') {
+        cb = options
+        options = null
+      }
+      function callback (er, stats) {
+        if (stats) {
+          if (stats.uid < 0) stats.uid += 0x100000000
+          if (stats.gid < 0) stats.gid += 0x100000000
+        }
+        if (cb) cb.apply(this, arguments)
+      }
+      return options ? orig.call(fs, target, options, callback)
+        : orig.call(fs, target, callback)
+    }
+  }
+
+  function statFixSync (orig) {
+    if (!orig) return orig
+    // Older versions of Node erroneously returned signed integers for
+    // uid + gid.
+    return function (target, options) {
+      var stats = options ? orig.call(fs, target, options)
+        : orig.call(fs, target)
+      if (stats) {
+        if (stats.uid < 0) stats.uid += 0x100000000
+        if (stats.gid < 0) stats.gid += 0x100000000
+      }
+      return stats;
+    }
+  }
+
+  // ENOSYS means that the fs doesn't support the op. Just ignore
+  // that, because it doesn't matter.
+  //
+  // if there's no getuid, or if getuid() is something other
+  // than 0, and the error is EINVAL or EPERM, then just ignore
+  // it.
+  //
+  // This specific case is a silent failure in cp, install, tar,
+  // and most other unix tools that manage permissions.
+  //
+  // When running as root, or if other types of errors are
+  // encountered, then it's strict.
+  function chownErOk (er) {
+    if (!er)
+      return true
+
+    if (er.code === "ENOSYS")
+      return true
+
+    var nonroot = !process.getuid || process.getuid() !== 0
+    if (nonroot) {
+      if (er.code === "EINVAL" || er.code === "EPERM")
+        return true
+    }
+
+    return false
+  }
+}
+
+
 /***/ }),
 
 /***/ 8675:
@@ -8709,7 +9682,7 @@ function sync (path, options) {
 
 var _fs
 try {
-  _fs = __webpack_require__(1317)
+  _fs = __webpack_require__(7156)
 } catch (_) {
   _fs = __webpack_require__(5747)
 }
@@ -22636,7 +23609,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.createGo = exports.getAnalyzedEntrypoint = exports.OUT_EXTENSION = exports.goGlobalCachePath = exports.cacheDir = void 0;
+exports.createGo = exports.GoWrapper = exports.getAnalyzedEntrypoint = exports.OUT_EXTENSION = exports.goGlobalCachePath = exports.localCacheDir = void 0;
 const tar_1 = __importDefault(__webpack_require__(6758));
 const execa_1 = __importDefault(__webpack_require__(389));
 const node_fetch_1 = __importDefault(__webpack_require__(779));
@@ -22651,7 +23624,7 @@ const yauzl_promise_1 = __importDefault(__webpack_require__(7542));
 const xdg_app_paths_1 = __importDefault(__webpack_require__(4925));
 const streamPipeline = util_1.promisify(stream_1.pipeline);
 const versionMap = new Map([
-    ['1.20', '1.20.1'],
+    ['1.20', '1.20.2'],
     ['1.19', '1.19.6'],
     ['1.18', '1.18.10'],
     ['1.17', '1.17.13'],
@@ -22665,16 +23638,26 @@ const archMap = new Map([
     ['x86', '386'],
 ]);
 const platformMap = new Map([['win32', 'windows']]);
-exports.cacheDir = path_1.join('.vercel', 'cache', 'golang');
+exports.localCacheDir = path_1.join('.vercel', 'cache', 'golang');
 const GO_FLAGS = process.platform === 'win32' ? [] : ['-ldflags', '-s -w'];
 const GO_MIN_VERSION = 13;
-const getPlatform = (p) => platformMap.get(p) || p;
-const getArch = (a) => archMap.get(a) || a;
+/**
+ * Determines the URL to download the Golang SDK.
+ * @param version The desireed Go version
+ * @returns The Go download URL
+ */
 function getGoUrl(version) {
     const { arch, platform } = process;
-    const goArch = getArch(arch);
-    const goPlatform = getPlatform(platform);
     const ext = platform === 'win32' ? 'zip' : 'tar.gz';
+    const goPlatform = platformMap.get(platform) || platform;
+    let goArch = archMap.get(arch) || arch;
+    // Go 1.16 was the first version to support arm64, so if the version is older
+    // we need to download the amd64 version
+    if (platform === 'darwin' &&
+        goArch === 'arm64' &&
+        parseInt(version.split('.')[1], 10) < 16) {
+        goArch = 'amd64';
+    }
     const filename = `go${version}.${goPlatform}-${goArch}.${ext}`;
     return {
         filename,
@@ -22683,23 +23666,69 @@ function getGoUrl(version) {
 }
 exports.goGlobalCachePath = path_1.join(xdg_app_paths_1.default('com.vercel.cli').cache(), 'golang');
 exports.OUT_EXTENSION = process.platform === 'win32' ? '.exe' : '';
-async function getAnalyzedEntrypoint(workPath, filePath, modulePath) {
+/**
+ * Parses the AST of the specified entrypoint Go file.
+ * @param workPath The work path (e.g. `/path/to/project`)
+ * @param entrypoint The path to the entrypoint file (e.g.
+ * `/path/to/project/api/index.go`)
+ * @param modulePath The path to the directory containing the `go.mod` (e.g.
+ * `/path/to/project/api`)
+ * @returns The results from the AST parsing
+ */
+async function getAnalyzedEntrypoint({ entrypoint, modulePath, workPath, }) {
     const bin = path_1.join(__dirname, `analyze${exports.OUT_EXTENSION}`);
-    const isAnalyzeExist = await fs_extra_1.pathExists(bin);
-    if (!isAnalyzeExist) {
-        build_utils_1.debug(`Building analyze bin: ${bin}`);
-        const src = __webpack_require__.ab + "analyze.go";
-        const go = await createGo({
-            modulePath,
-            workPath,
-        });
-        await go.build(__webpack_require__.ab + "analyze.go", bin);
+    let analyzed;
+    try {
+        // build the `analyze` binary if not found in the `dist` directory
+        const isAnalyzeExist = await fs_extra_1.pathExists(bin);
+        if (!isAnalyzeExist) {
+            build_utils_1.debug(`Building analyze bin: ${bin}`);
+            const src = __webpack_require__.ab + "analyze.go";
+            let go;
+            const createOpts = {
+                modulePath,
+                opts: { cwd: __dirname },
+                workPath,
+            };
+            try {
+                go = await createGo(createOpts);
+            }
+            catch (err) {
+                // if the version in the `go.mod` is too old, then download the latest
+                if (err instanceof GoError &&
+                    err.code === 'ERR_UNSUPPORTED_GO_VERSION') {
+                    delete createOpts.modulePath;
+                    go = await createGo(createOpts);
+                }
+                else {
+                    throw err;
+                }
+            }
+            await go.build(__webpack_require__.ab + "analyze.go", bin);
+        }
+    }
+    catch (err) {
+        console.error('Failed to build the Go AST analyzer');
+        throw err;
+    }
+    try {
+        build_utils_1.debug(`Analyzing entrypoint ${entrypoint} with modulePath ${modulePath}`);
+        const args = [`-modpath=${modulePath}`, path_1.join(workPath, entrypoint)];
+        analyzed = await execa_1.default.stdout(bin, args);
+    }
+    catch (err) {
+        console.error(`Failed to parse AST for "${entrypoint}"`);
+        throw err;
     }
-    build_utils_1.debug(`Analyzing entrypoint ${filePath} with modulePath ${modulePath}`);
-    const args = [`-modpath=${modulePath}`, filePath];
-    const analyzed = await execa_1.default.stdout(bin, args);
     build_utils_1.debug(`Analyzed entrypoint ${analyzed}`);
-    return analyzed;
+    if (!analyzed) {
+        const err = new Error(`Could not find an exported function in "${entrypoint}"
+Learn more: https://vercel.com/docs/runtimes#official-runtimes/go
+      `);
+        console.error(err.message);
+        throw err;
+    }
+    return JSON.parse(analyzed);
 }
 exports.getAnalyzedEntrypoint = getAnalyzedEntrypoint;
 class GoWrapper {
@@ -22712,9 +23741,10 @@ class GoWrapper {
     }
     execute(...args) {
         const { opts, env } = this;
-        build_utils_1.debug(`Exec: go ${args
-            .map(a => (a.includes(' ') ? `"${a}"` : a))
-            .join(' ')} CWD=${opts.cwd}`);
+        build_utils_1.debug(`Exec: go ${args.map(a => (a.includes(' ') ? `"${a}"` : a)).join(' ')}`);
+        build_utils_1.debug(`  CWD=${opts.cwd}`);
+        build_utils_1.debug(`  GOROOT=${(env || opts.env).GOROOT}`);
+        build_utils_1.debug(`  GO_BUILD_FLAGS=${(env || opts.env).GO_BUILD_FLAGS}`);
         return execa_1.default('go', args, { stdio: 'inherit', ...opts, env });
     }
     mod() {
@@ -22734,12 +23764,12 @@ class GoWrapper {
     build(src, dest) {
         build_utils_1.debug(`Building optimized 'go' binary ${src} -> ${dest}`);
         const sources = Array.isArray(src) ? src : [src];
-        const flags = process.env.GO_BUILD_FLAGS
-            ? string_argv_1.default(process.env.GO_BUILD_FLAGS)
-            : GO_FLAGS;
+        const envGoBuildFlags = (this.env || this.opts.env).GO_BUILD_FLAGS;
+        const flags = envGoBuildFlags ? string_argv_1.default(envGoBuildFlags) : GO_FLAGS;
         return this.execute('build', ...flags, '-o', dest, ...sources);
     }
 }
+exports.GoWrapper = GoWrapper;
 /**
  * Initializes a `GoWrapper` instance.
  *
@@ -22775,7 +23805,7 @@ async function createGo({ modulePath, opts = {}, workPath, }) {
     const { PATH } = env;
     const { platform } = process;
     const goGlobalCacheDir = path_1.join(exports.goGlobalCachePath, `${goSelectedVersion}_${platform}_${process.arch}`);
-    const goCacheDir = path_1.join(workPath, exports.cacheDir);
+    const goCacheDir = path_1.join(workPath, exports.localCacheDir);
     if (goPreferredVersion) {
         build_utils_1.debug(`Preferred go version ${goPreferredVersion} (from go.mod)`);
         env.GO111MODULE = 'on';
@@ -22815,7 +23845,7 @@ async function createGo({ modulePath, opts = {}, workPath, }) {
                 build_utils_1.debug(`Found go ${version} in ${label}, but version is unsupported`);
             }
             if (version === goSelectedVersion || short === goSelectedVersion) {
-                console.log(`Selected go ${version} (from ${label})`);
+                build_utils_1.debug(`Selected go ${version} (from ${label})`);
                 await setGoEnv(goDir);
                 return new GoWrapper(env, opts);
             }
@@ -22910,6 +23940,8 @@ function parseGoVersionString(goVersionOutput) {
         patch,
     };
 }
+class GoError extends Error {
+}
 /**
  * Attempts to parse the preferred Go version from the `go.mod` file.
  *
@@ -22928,6 +23960,11 @@ async function parseGoModVersion(modulePath) {
         if (major === 1 && minor >= GO_MIN_VERSION && full) {
             version = full;
         }
+        else if (!isNaN(minor)) {
+            const err = new GoError(`Unsupported Go version ${major}.${minor} in ${file}`);
+            err.code = 'ERR_UNSUPPORTED_GO_VERSION';
+            throw err;
+        }
         else {
             console.log(`Warning: Unknown Go version in ${file}`);
         }
@@ -22967,7 +24004,10 @@ const build_utils_1 = __webpack_require__(3445);
 Object.defineProperty(exports, "shouldServe", ({ enumerable: true, get: function () { return build_utils_1.shouldServe; } }));
 const TMP = os_1.tmpdir();
 const go_helpers_1 = __webpack_require__(3097);
-const handlerFileName = `handler${go_helpers_1.OUT_EXTENSION}`;
+// in order to allow the user to have `main.go`,
+// we need our `main.go` to be called something else
+const MAIN_GO_FILENAME = 'main__vc__go__.go';
+const HANDLER_FILENAME = `handler${go_helpers_1.OUT_EXTENSION}`;
 // Initialize private git repo for Go Modules
 async function initPrivateGit(credentials) {
     const gitCredentialsPath = path_1.join(os_1.homedir(), '.git-credentials');
@@ -23004,15 +24044,21 @@ async function build({ files, entrypoint, config, workPath, meta = {}, }) {
     // keep track of file system actions we need to undo
     // the keys "from" and "to" refer to what needs to be done
     // in order to undo the action, not what the original action was
-    const undoFileActions = [];
-    const undoDirectoryCreation = [];
-    const undoFunctionRenames = [];
+    const undo = {
+        fileActions: [],
+        directoryCreation: [],
+        functionRenames: [],
+    };
+    const env = build_utils_1.cloneEnv(process.env, meta.env, {
+        GOARCH: 'amd64',
+        GOOS: 'linux',
+    });
     try {
-        if (process.env.GIT_CREDENTIALS) {
+        if (env.GIT_CREDENTIALS) {
             build_utils_1.debug('Initialize Git credentials...');
-            await initPrivateGit(process.env.GIT_CREDENTIALS);
+            await initPrivateGit(env.GIT_CREDENTIALS);
         }
-        if (process.env.GO111MODULE) {
+        if (env.GO111MODULE) {
             console.log(`\nManually assigning 'GO111MODULE' is not recommended.
 
   By default:
@@ -23027,290 +24073,82 @@ async function build({ files, entrypoint, config, workPath, meta = {}, }) {
         const renamedEntrypoint = getRenamedEntrypoint(entrypoint);
         if (renamedEntrypoint) {
             await fs_extra_1.move(path_1.join(workPath, entrypoint), path_1.join(workPath, renamedEntrypoint));
-            undoFileActions.push({
+            undo.fileActions.push({
                 to: path_1.join(workPath, entrypoint),
                 from: path_1.join(workPath, renamedEntrypoint),
             });
             entrypoint = renamedEntrypoint;
         }
         const entrypointAbsolute = path_1.join(workPath, entrypoint);
-        const entrypointArr = entrypoint.split(path_1.posix.sep);
-        build_utils_1.debug(`Parsing AST for "${entrypoint}"`);
-        let analyzed;
-        try {
-            const goModAbsPath = await findGoModPath(workPath);
-            if (goModAbsPath) {
-                build_utils_1.debug(`Found ${goModAbsPath}"`);
-            }
-            analyzed = await go_helpers_1.getAnalyzedEntrypoint(workPath, entrypointAbsolute, path_1.dirname(goModAbsPath));
-        }
-        catch (err) {
-            console.error(`Failed to parse AST for "${entrypoint}"`);
-            throw err;
-        }
-        if (!analyzed) {
-            const err = new Error(`Could not find an exported function in "${entrypoint}"
-  Learn more: https://vercel.com/docs/runtimes#official-runtimes/go
-        `);
-            console.error(err.message);
-            throw err;
-        }
-        const parsedAnalyzed = JSON.parse(analyzed);
-        // find `go.mod` in modFiles
         const entrypointDirname = path_1.dirname(entrypointAbsolute);
-        let isGoModExist = false;
-        let goModPath = '';
-        let isGoModInRootDir = false;
-        const modFileRefs = await build_utils_1.glob('**/*.mod', workPath);
-        const modFiles = Object.keys(modFileRefs);
-        for (const file of modFiles) {
-            const fileDirname = path_1.dirname(file);
-            if (file === 'go.mod') {
-                isGoModExist = true;
-                isGoModInRootDir = true;
-                goModPath = path_1.join(workPath, fileDirname);
-            }
-            else if (file.endsWith('go.mod')) {
-                if (entrypointDirname === fileDirname) {
-                    isGoModExist = true;
-                    goModPath = path_1.join(workPath, fileDirname);
-                    build_utils_1.debug(`Found file dirname equals entrypoint dirname: ${fileDirname}`);
-                    break;
-                }
-                if (!isGoModInRootDir && config.zeroConfig && file === 'api/go.mod') {
-                    // We didn't find `/go.mod` but we found `/api/go.mod` so move it to the root
-                    isGoModExist = true;
-                    isGoModInRootDir = true;
-                    goModPath = path_1.join(fileDirname, '..');
-                    const pathParts = file.split(path_1.sep);
-                    pathParts.pop(); // Remove go.mod
-                    pathParts.pop(); // Remove api
-                    pathParts.push('go.mod');
-                    const newRoot = pathParts.join(path_1.sep);
-                    const newFsPath = path_1.join(workPath, newRoot);
-                    build_utils_1.debug(`Moving api/go.mod to root: ${file} to ${newFsPath}`);
-                    await fs_extra_1.move(file, newFsPath);
-                    undoFileActions.push({
-                        to: file,
-                        from: newFsPath,
-                    });
-                    const oldSumPath = path_1.join(path_1.dirname(file), 'go.sum');
-                    const newSumPath = path_1.join(path_1.dirname(newFsPath), 'go.sum');
-                    if (await fs_extra_1.pathExists(oldSumPath)) {
-                        build_utils_1.debug(`Moving api/go.sum to root: ${oldSumPath} to ${newSumPath}`);
-                        await fs_extra_1.move(oldSumPath, newSumPath);
-                        undoFileActions.push({
-                            to: oldSumPath,
-                            from: newSumPath,
-                        });
-                    }
-                    break;
-                }
-            }
+        const { goModPath, isGoModInRootDir } = await findGoModPath(entrypointDirname, workPath);
+        if (!goModPath && (await fs_extra_1.pathExists(path_1.join(workPath, 'vendor')))) {
+            throw new Error('`go.mod` is required to use a `vendor` directory.');
+        }
+        const analyzed = await go_helpers_1.getAnalyzedEntrypoint({
+            entrypoint,
+            modulePath: goModPath ? path_1.dirname(goModPath) : undefined,
+            workPath,
+        });
+        // check if package name other than main
+        // using `go.mod` way building the handler
+        const packageName = analyzed.packageName;
+        if (goModPath && packageName === 'main') {
+            throw new Error('Please change `package main` to `package handler`');
         }
-        const input = entrypointDirname;
+        // rename the Go handler function name in the original entrypoint file
+        const originalFunctionName = analyzed.functionName;
+        const handlerFunctionName = getNewHandlerFunctionName(originalFunctionName, entrypoint);
+        await renameHandlerFunction(entrypointAbsolute, originalFunctionName, handlerFunctionName);
+        undo.functionRenames.push({
+            fsPath: originalEntrypointAbsolute,
+            from: handlerFunctionName,
+            to: originalFunctionName,
+        });
         const includedFiles = {};
         if (config && config.includeFiles) {
             const patterns = Array.isArray(config.includeFiles)
                 ? config.includeFiles
                 : [config.includeFiles];
             for (const pattern of patterns) {
-                const fsFiles = await build_utils_1.glob(pattern, input);
+                const fsFiles = await build_utils_1.glob(pattern, entrypointDirname);
                 for (const [assetName, asset] of Object.entries(fsFiles)) {
                     includedFiles[assetName] = asset;
                 }
             }
         }
-        const originalFunctionName = parsedAnalyzed.functionName;
-        const handlerFunctionName = getNewHandlerFunctionName(originalFunctionName, entrypoint);
-        await renameHandlerFunction(entrypointAbsolute, originalFunctionName, handlerFunctionName);
-        undoFunctionRenames.push({
-            fsPath: originalEntrypointAbsolute,
-            from: handlerFunctionName,
-            to: originalFunctionName,
-        });
-        if (!isGoModExist) {
-            if (await fs_extra_1.pathExists(path_1.join(workPath, 'vendor'))) {
-                throw new Error('`go.mod` is required to use a `vendor` directory.');
-            }
-        }
-        // check if package name other than main
-        // using `go.mod` way building the handler
-        const packageName = parsedAnalyzed.packageName;
-        if (isGoModExist && packageName === 'main') {
-            throw new Error('Please change `package main` to `package handler`');
-        }
-        const outDir = await build_utils_1.getWriteableDirectory();
-        // in order to allow the user to have `main.go`,
-        // we need our `main.go` to be called something else
-        const mainGoFileName = 'main__vc__go__.go';
+        const modulePath = goModPath ? path_1.dirname(goModPath) : undefined;
         const go = await go_helpers_1.createGo({
-            modulePath: goModPath,
+            modulePath,
             opts: {
                 cwd: entrypointDirname,
-                env: {
-                    GOARCH: 'amd64',
-                    GOOS: 'linux',
-                },
+                env,
             },
             workPath,
         });
-        if (packageName !== 'main') {
-            if (!isGoModExist) {
-                try {
-                    const defaultGoModContent = `module ${packageName}`;
-                    await fs_extra_1.writeFile(path_1.join(entrypointDirname, 'go.mod'), defaultGoModContent);
-                    undoFileActions.push({
-                        to: undefined,
-                        from: path_1.join(entrypointDirname, 'go.mod'),
-                    });
-                    // remove the `go.sum` file that will be generated as well
-                    undoFileActions.push({
-                        to: undefined,
-                        from: path_1.join(entrypointDirname, 'go.sum'),
-                    });
-                }
-                catch (err) {
-                    console.error(`Failed to create default go.mod for ${packageName}`);
-                    throw err;
-                }
-            }
-            const modMainGoContents = await fs_extra_1.readFile(__webpack_require__.ab + "main.go", 'utf8');
-            let goPackageName = `${packageName}/${packageName}`;
-            const goFuncName = `${packageName}.${handlerFunctionName}`;
-            if (isGoModExist) {
-                const goModContents = await fs_extra_1.readFile(path_1.join(goModPath, 'go.mod'), 'utf8');
-                const usrModName = goModContents.split('\n')[0].split(' ')[1];
-                if (entrypointArr.length > 1 && isGoModInRootDir) {
-                    const cleanPackagePath = [...entrypointArr];
-                    cleanPackagePath.pop();
-                    goPackageName = `${usrModName}/${cleanPackagePath.join('/')}`;
-                }
-                else {
-                    goPackageName = `${usrModName}/${packageName}`;
-                }
-            }
-            const mainModGoContents = modMainGoContents
-                .replace('__VC_HANDLER_PACKAGE_NAME', goPackageName)
-                .replace('__VC_HANDLER_FUNC_NAME', goFuncName);
-            if (isGoModExist && isGoModInRootDir) {
-                build_utils_1.debug('[mod-root] Write main file to ' + downloadPath);
-                await fs_extra_1.writeFile(path_1.join(downloadPath, mainGoFileName), mainModGoContents);
-                undoFileActions.push({
-                    to: undefined,
-                    from: path_1.join(downloadPath, mainGoFileName),
-                });
-            }
-            else if (isGoModExist && !isGoModInRootDir) {
-                build_utils_1.debug('[mod-other] Write main file to ' + goModPath);
-                await fs_extra_1.writeFile(path_1.join(goModPath, mainGoFileName), mainModGoContents);
-                undoFileActions.push({
-                    to: undefined,
-                    from: path_1.join(goModPath, mainGoFileName),
-                });
-            }
-            else {
-                build_utils_1.debug('[entrypoint] Write main file to ' + entrypointDirname);
-                await fs_extra_1.writeFile(path_1.join(entrypointDirname, mainGoFileName), mainModGoContents);
-                undoFileActions.push({
-                    to: undefined,
-                    from: path_1.join(entrypointDirname, mainGoFileName),
-                });
-            }
-            // move user go file to folder
-            try {
-                // default path
-                let finalDestination = path_1.join(entrypointDirname, packageName, entrypoint);
-                // if `entrypoint` include folder, only use filename
-                if (entrypointArr.length > 1) {
-                    finalDestination = path_1.join(entrypointDirname, packageName, entrypointArr[entrypointArr.length - 1]);
-                }
-                if (path_1.dirname(entrypointAbsolute) === goModPath || !isGoModExist) {
-                    build_utils_1.debug(`moving entrypoint "${entrypointAbsolute}" to "${finalDestination}"`);
-                    await fs_extra_1.move(entrypointAbsolute, finalDestination);
-                    undoFileActions.push({
-                        to: entrypointAbsolute,
-                        from: finalDestination,
-                    });
-                    undoDirectoryCreation.push(path_1.dirname(finalDestination));
-                }
-            }
-            catch (err) {
-                console.error('Failed to move entry to package folder');
-                throw err;
-            }
-            let baseGoModPath = '';
-            if (isGoModExist && isGoModInRootDir) {
-                baseGoModPath = downloadPath;
-            }
-            else if (isGoModExist && !isGoModInRootDir) {
-                baseGoModPath = goModPath;
-            }
-            else {
-                baseGoModPath = entrypointDirname;
-            }
-            build_utils_1.debug('Tidy `go.mod` file...');
-            try {
-                // ensure go.mod up-to-date
-                await go.mod();
-            }
-            catch (err) {
-                console.error('failed to `go mod tidy`');
-                throw err;
-            }
-            build_utils_1.debug('Running `go build`...');
-            const destPath = path_1.join(outDir, handlerFileName);
-            try {
-                const src = [path_1.join(baseGoModPath, mainGoFileName)];
-                await go.build(src, destPath);
-            }
-            catch (err) {
-                console.error('failed to `go build`');
-                throw err;
-            }
+        const outDir = await build_utils_1.getWriteableDirectory();
+        const buildOptions = {
+            downloadPath,
+            entrypoint,
+            entrypointAbsolute,
+            entrypointDirname,
+            go,
+            goModPath,
+            handlerFunctionName,
+            isGoModInRootDir,
+            outDir,
+            packageName,
+            undo,
+        };
+        if (packageName === 'main') {
+            await buildHandlerAsPackageMain(buildOptions);
         }
         else {
-            // legacy mode
-            // we need `main.go` in the same dir as the entrypoint,
-            // otherwise `go build` will refuse to build
-            const originalMainGoContents = await fs_extra_1.readFile(__webpack_require__.ab + "main.go", 'utf8');
-            const mainGoContents = originalMainGoContents
-                .replace('"__VC_HANDLER_PACKAGE_NAME"', '')
-                .replace('__VC_HANDLER_FUNC_NAME', handlerFunctionName);
-            // Go doesn't like to build files in different directories,
-            // so now we place `main.go` together with the user code
-            await fs_extra_1.writeFile(path_1.join(entrypointDirname, mainGoFileName), mainGoContents);
-            undoFileActions.push({
-                to: undefined,
-                from: path_1.join(entrypointDirname, mainGoFileName),
-            });
-            // `go get` will look at `*.go` (note we set `cwd`), parse the `import`s
-            // and download any packages that aren't part of the stdlib
-            build_utils_1.debug('Running `go get`...');
-            try {
-                await go.get();
-            }
-            catch (err) {
-                console.error('Failed to `go get`');
-                throw err;
-            }
-            build_utils_1.debug('Running `go build`...');
-            const destPath = path_1.join(outDir, handlerFileName);
-            try {
-                const src = [
-                    path_1.join(entrypointDirname, mainGoFileName),
-                    entrypointAbsolute,
-                ].map(file => path_1.normalize(file));
-                await go.build(src, destPath);
-            }
-            catch (err) {
-                console.error('failed to `go build`');
-                throw err;
-            }
+            await buildHandlerWithGoMod(buildOptions);
         }
-        const lambda = await build_utils_1.createLambda({
+        const lambda = new build_utils_1.Lambda({
             files: { ...(await build_utils_1.glob('**', outDir)), ...includedFiles },
-            handler: handlerFileName,
+            handler: HANDLER_FILENAME,
             runtime: 'go1.x',
             supportsWrapper: true,
             environment: {},
@@ -23320,12 +24158,12 @@ async function build({ files, entrypoint, config, workPath, meta = {}, }) {
         };
     }
     catch (error) {
-        build_utils_1.debug('Go Builder Error: ' + error);
+        build_utils_1.debug(`Go Builder Error: ${error}`);
         throw error;
     }
     finally {
         try {
-            await cleanupFileSystem(undoFileActions, undoDirectoryCreation, undoFunctionRenames);
+            await cleanupFileSystem(undo);
         }
         catch (error) {
             if (error instanceof Error) {
@@ -23336,6 +24174,156 @@ async function build({ files, entrypoint, config, workPath, meta = {}, }) {
     }
 }
 exports.build = build;
+/**
+ * Build the Go function where the package name is not `"main"`. If a `go.mod`
+ * does not exist, a default one will be used.
+ */
+async function buildHandlerWithGoMod({ downloadPath, entrypoint, entrypointAbsolute, entrypointDirname, go, goModPath, handlerFunctionName, isGoModInRootDir, outDir, packageName, undo, }) {
+    build_utils_1.debug(`Building Go handler as package "${packageName}" (with${goModPath ? '' : 'out'} go.mod)`);
+    let goModDirname;
+    if (goModPath !== undefined) {
+        goModDirname = path_1.dirname(goModPath);
+        // first we backup the original
+        const backupFile = path_1.join(goModDirname, `__vc_go.mod.bak`);
+        await fs_extra_1.copy(goModPath, backupFile);
+        undo.fileActions.push({
+            to: goModPath,
+            from: backupFile,
+        });
+        const goSumPath = path_1.join(goModDirname, 'go.sum');
+        const isGoSumExists = await fs_extra_1.pathExists(goSumPath);
+        if (!isGoSumExists) {
+            // remove the `go.sum` file that will be generated as well
+            undo.fileActions.push({
+                to: undefined,
+                from: goSumPath,
+            });
+        }
+    }
+    const entrypointArr = entrypoint.split(path_1.posix.sep);
+    let goPackageName = `${packageName}/${packageName}`;
+    const goFuncName = `${packageName}.${handlerFunctionName}`;
+    // if we have a go.mod, determine the relative path of the entrypoint to the
+    // go.mod directory and use that for the import package name in main.go
+    const relPackagePath = goModDirname
+        ? path_1.posix.relative(goModDirname, entrypointDirname)
+        : '';
+    if (relPackagePath) {
+        goPackageName = path_1.posix.join(packageName, relPackagePath);
+    }
+    let mainGoFile;
+    if (goModPath && isGoModInRootDir) {
+        build_utils_1.debug(`[mod-root] Write main file to ${downloadPath}`);
+        mainGoFile = path_1.join(downloadPath, MAIN_GO_FILENAME);
+    }
+    else if (goModDirname && !isGoModInRootDir) {
+        build_utils_1.debug(`[mod-other] Write main file to ${goModDirname}`);
+        mainGoFile = path_1.join(goModDirname, MAIN_GO_FILENAME);
+    }
+    else {
+        build_utils_1.debug(`[entrypoint] Write main file to ${entrypointDirname}`);
+        mainGoFile = path_1.join(entrypointDirname, MAIN_GO_FILENAME);
+    }
+    await Promise.all([
+        writeEntrypoint(mainGoFile, goPackageName, goFuncName),
+        writeGoMod({
+            destDir: goModDirname ? goModDirname : entrypointDirname,
+            goModPath,
+            packageName,
+        }),
+    ]);
+    undo.fileActions.push({
+        to: undefined,
+        from: mainGoFile,
+    });
+    // move user go file to folder
+    try {
+        // default path
+        let finalDestination = path_1.join(entrypointDirname, packageName, entrypoint);
+        // if `entrypoint` include folder, only use filename
+        if (entrypointArr.length > 1) {
+            finalDestination = path_1.join(entrypointDirname, packageName, entrypointArr[entrypointArr.length - 1]);
+        }
+        if (!goModPath || path_1.dirname(entrypointAbsolute) === path_1.dirname(goModPath)) {
+            build_utils_1.debug(`moving entrypoint "${entrypointAbsolute}" to "${finalDestination}"`);
+            await fs_extra_1.move(entrypointAbsolute, finalDestination);
+            undo.fileActions.push({
+                to: entrypointAbsolute,
+                from: finalDestination,
+            });
+            undo.directoryCreation.push(path_1.dirname(finalDestination));
+        }
+    }
+    catch (err) {
+        console.error('Failed to move entry to package folder');
+        throw err;
+    }
+    let baseGoModPath = '';
+    if (goModPath && isGoModInRootDir) {
+        baseGoModPath = downloadPath;
+    }
+    else if (goModPath && !isGoModInRootDir) {
+        baseGoModPath = path_1.dirname(goModPath);
+    }
+    else {
+        baseGoModPath = entrypointDirname;
+    }
+    build_utils_1.debug('Tidy `go.mod` file...');
+    try {
+        // ensure go.mod up-to-date
+        await go.mod();
+    }
+    catch (err) {
+        console.error('failed to `go mod tidy`');
+        throw err;
+    }
+    build_utils_1.debug('Running `go build`...');
+    const destPath = path_1.join(outDir, HANDLER_FILENAME);
+    try {
+        const src = [path_1.join(baseGoModPath, MAIN_GO_FILENAME)];
+        await go.build(src, destPath);
+    }
+    catch (err) {
+        console.error('failed to `go build`');
+        throw err;
+    }
+}
+/**
+ * Builds the wrapped Go function using the legacy mode where package name is
+ * `"main"` and we need `main.go` in the same dir as the entrypoint, otherwise
+ * `go build` will refuse to build.
+ */
+async function buildHandlerAsPackageMain({ entrypointAbsolute, entrypointDirname, go, handlerFunctionName, outDir, undo, }) {
+    build_utils_1.debug('Building Go handler as package "main" (legacy)');
+    await writeEntrypoint(path_1.join(entrypointDirname, MAIN_GO_FILENAME), '', handlerFunctionName);
+    undo.fileActions.push({
+        to: undefined,
+        from: path_1.join(entrypointDirname, MAIN_GO_FILENAME),
+    });
+    // `go get` will look at `*.go` (note we set `cwd`), parse the `import`s
+    // and download any packages that aren't part of the stdlib
+    build_utils_1.debug('Running `go get`...');
+    try {
+        await go.get();
+    }
+    catch (err) {
+        console.error('Failed to `go get`');
+        throw err;
+    }
+    build_utils_1.debug('Running `go build`...');
+    const destPath = path_1.join(outDir, HANDLER_FILENAME);
+    try {
+        const src = [
+            path_1.join(entrypointDirname, MAIN_GO_FILENAME),
+            entrypointAbsolute,
+        ].map(file => path_1.normalize(file));
+        await go.build(src, destPath);
+    }
+    catch (err) {
+        console.error('failed to `go build`');
+        throw err;
+    }
+}
 async function renameHandlerFunction(fsPath, from, to) {
     let fileContents = await fs_extra_1.readFile(fsPath, 'utf8');
     // This regex has to walk a fine line where it replaces the most-likely occurrences
@@ -23362,13 +24350,16 @@ function getNewHandlerFunctionName(originalFunctionName, entrypoint) {
     return newHandlerName;
 }
 exports.getNewHandlerFunctionName = getNewHandlerFunctionName;
-async function cleanupFileSystem(undoFileActions, undoDirectoryCreation, undoFunctionRenames) {
+/**
+ * Remove any temporary files, directories, and file changes.
+ */
+async function cleanupFileSystem({ fileActions, directoryCreation, functionRenames, }) {
     // we have to undo the actions in reverse order in cases
     // where one file was moved multiple times, which happens
     // using files that start with brackets
-    for (const action of undoFileActions.reverse()) {
+    for (const action of fileActions.reverse()) {
         if (action.to) {
-            await fs_extra_1.move(action.from, action.to);
+            await fs_extra_1.move(action.from, action.to, { overwrite: true });
         }
         else {
             await fs_extra_1.remove(action.from);
@@ -23376,10 +24367,10 @@ async function cleanupFileSystem(undoFileActions, undoDirectoryCreation, undoFun
     }
     // after files are moved back, we can undo function renames
     // these reference the original file location
-    for (const rename of undoFunctionRenames) {
+    for (const rename of functionRenames) {
         await renameHandlerFunction(rename.fsPath, rename.from, rename.to);
     }
-    const undoDirectoryPromises = undoDirectoryCreation.map(async (directory) => {
+    const undoDirectoryPromises = directoryCreation.map(async (directory) => {
         const contents = await fs_extra_1.readdir(directory);
         // only delete an empty directory
         // if it has contents, either something went wrong during cleanup or this
@@ -23391,16 +24382,32 @@ async function cleanupFileSystem(undoFileActions, undoDirectoryCreation, undoFun
     });
     await Promise.all(undoDirectoryPromises);
 }
-async function findGoModPath(workPath) {
-    let checkPath = path_1.join(workPath, 'go.mod');
-    if (await fs_extra_1.pathExists(checkPath)) {
-        return checkPath;
-    }
-    checkPath = path_1.join(workPath, 'api/go.mod');
-    if (await fs_extra_1.pathExists(checkPath)) {
-        return checkPath;
+/**
+ * Attempts to find a `go.mod` starting in the entrypoint directory and
+ * scanning up the directory tree.
+ * @param entrypointDir The entrypoint directory (e.g. `/path/to/project/api`)
+ * @param workPath  The work path (e.g. `/path/to/project`)
+ * @returns The absolute path to the `go.mod` and a flag if the `go.mod` is in
+ * the work path root
+ */
+async function findGoModPath(entrypointDir, workPath) {
+    let goModPath = undefined;
+    let isGoModInRootDir = false;
+    let dir = entrypointDir;
+    while (!isGoModInRootDir) {
+        isGoModInRootDir = dir === workPath;
+        const goMod = path_1.join(dir, 'go.mod');
+        if (await fs_extra_1.pathExists(goMod)) {
+            goModPath = goMod;
+            build_utils_1.debug(`Found ${goModPath}"`);
+            break;
+        }
+        dir = path_1.dirname(dir);
     }
-    return '';
+    return {
+        goModPath,
+        isGoModInRootDir,
+    };
 }
 function isPortInfo(v) {
     return v && typeof v.port === 'number';
@@ -23420,9 +24427,126 @@ async function copyDevServer(functionName, dest) {
     const patched = data.replace('__HANDLER_FUNC_NAME', functionName);
     await fs_extra_1.writeFile(path_1.join(dest, 'vercel-dev-server-main.go'), patched);
 }
-async function writeDefaultGoMod(entrypointDirname, packageName) {
-    const defaultGoModContent = `module ${packageName}`;
-    await fs_extra_1.writeFile(path_1.join(entrypointDirname, 'go.mod'), defaultGoModContent, 'utf-8');
+async function writeEntrypoint(dest, goPackageName, goFuncName) {
+    const modMainGoContents = await fs_extra_1.readFile(__webpack_require__.ab + "main.go", 'utf8');
+    const mainModGoContents = modMainGoContents
+        .replace('__VC_HANDLER_PACKAGE_NAME', goPackageName)
+        .replace('__VC_HANDLER_FUNC_NAME', goFuncName);
+    await fs_extra_1.writeFile(dest, mainModGoContents, 'utf-8');
+}
+/**
+ * Writes a `go.mod` file in the specified directory. If a `go.mod` file
+ * exists, then update the module name and any relative `replace` statements,
+ * otherwise write the minimum module name.
+ * @param workPath The work path; required if `goModPath` exists
+ * @param goModPath The path to the `go.mod`, or `undefined` if not found
+ * @param destDir The directory to write the `go.mod` to
+ * @param packageName The module name to inject into the `go.mod`
+ */
+async function writeGoMod({ destDir, goModPath, packageName, }) {
+    let contents = `module ${packageName}`;
+    if (goModPath) {
+        const goModRelPath = path_1.relative(destDir, path_1.dirname(goModPath));
+        const goModContents = await fs_extra_1.readFile(goModPath, 'utf-8');
+        contents = goModContents
+            .replace(/^module\s+.+$/m, contents)
+            .replace(/^(replace .+=>\s*)(.+)$/gm, (orig, replaceStmt, replacePath) => {
+            if (replacePath.startsWith('.')) {
+                return replaceStmt + path_1.join(goModRelPath, replacePath);
+            }
+            return orig;
+        });
+        // get the module name, then add the 'replace' mapping if it doesn't
+        // already exist
+        const matches = goModContents.match(/module\s+(.+)/);
+        const moduleName = matches ? matches[1] : null;
+        if (moduleName) {
+            let relPath = path_1.normalize(goModRelPath);
+            if (!relPath.endsWith('/')) {
+                relPath += '/';
+            }
+            const requireRE = new RegExp(`require\\s+${moduleName}`);
+            const requireGroupRE = new RegExp(`require\\s*\\(.*${moduleName}.*\\)`, 's');
+            if (!requireRE.test(contents) && !requireGroupRE.test(contents)) {
+                contents += `require ${moduleName} v0.0.0-unpublished\n`;
+            }
+            const replaceRE = new RegExp(`replace.+=>\\s+${relPath}(\\s|$)`);
+            if (!replaceRE.test(contents)) {
+                contents += `replace ${moduleName} => ${relPath}\n`;
+            }
+        }
+    }
+    const destGoModPath = path_1.join(destDir, 'go.mod');
+    build_utils_1.debug(`Writing ${destGoModPath}`);
+    // console.log(contents);
+    await fs_extra_1.writeFile(destGoModPath, contents, 'utf-8');
+}
+/**
+ * Attempts to find the `go.work` file. It will stop once it hits the
+ * `workPath`.
+ * @param goWorkDir The directory under the `wordPath` to start searching.
+ * @param workPath The project root to stop looking for the file.
+ * @returns The path to the `go.work` file or `undefined`.
+ */
+async function findGoWorkFile(goWorkDir, workPath) {
+    while (!(await fs_extra_1.pathExists(path_1.join(goWorkDir, 'go.work')))) {
+        if (goWorkDir === workPath) {
+            return;
+        }
+        goWorkDir = path_1.dirname(goWorkDir);
+    }
+    return path_1.join(goWorkDir, 'go.work');
+}
+/**
+ * For simple cases, a `go.work` file is not required. However when a Go
+ * program requires source files outside the work path, we need a `go.work` so
+ * Go can find the root of the project being built.
+ * @param destDir The destination directory to write the `go.work` file.
+ * @param workPath The path to the work directory.
+ * @param modulePath The path to the directory containing the `go.mod`.
+ */
+async function writeGoWork(destDir, workPath, modulePath) {
+    const workspaces = new Set(['.']);
+    const goWorkPath = await findGoWorkFile(modulePath || workPath, workPath);
+    if (goWorkPath) {
+        const contents = await fs_extra_1.readFile(goWorkPath, 'utf-8');
+        const addPath = (path) => {
+            if (path) {
+                if (path.startsWith('.')) {
+                    workspaces.add(path_1.relative(destDir, path_1.join(workPath, path)));
+                }
+                else {
+                    workspaces.add(path);
+                }
+            }
+        };
+        // find grouped paths
+        const multiRE = /use\s*\(([^)]+)/g;
+        let match = multiRE.exec(contents);
+        while (match) {
+            if (match[1]) {
+                for (const line of match[1].split(/\r?\n/)) {
+                    addPath(line.trim());
+                }
+            }
+            match = multiRE.exec(contents);
+        }
+        // find single paths
+        const singleRE = /use\s+(?!\()(.+)/g;
+        match = singleRE.exec(contents);
+        while (match) {
+            addPath(match[1].trim());
+            match = singleRE.exec(contents);
+        }
+    }
+    else if (modulePath) {
+        workspaces.add(path_1.relative(destDir, modulePath));
+    }
+    const contents = `use (\n${Array.from(workspaces)
+        .map(w => `  ${w}\n`)
+        .join('')})\n`;
+    // console.log(contents);
+    await fs_extra_1.writeFile(path_1.join(destDir, 'go.work'), contents, 'utf-8');
 }
 async function startDevServer(opts) {
     const { entrypoint, workPath, meta = {} } = opts;
@@ -23437,20 +24561,22 @@ async function startDevServer(opts) {
     const tmp = path_1.join(devCacheDir, 'go', Math.random().toString(32).substring(2));
     const tmpPackage = path_1.join(tmp, entrypointDir);
     await fs_extra_1.mkdirp(tmpPackage);
-    let goModAbsPathDir = '';
-    if (await fs_extra_1.pathExists(path_1.join(workPath, 'go.mod'))) {
-        goModAbsPathDir = workPath;
-    }
-    const analyzedRaw = await go_helpers_1.getAnalyzedEntrypoint(workPath, entrypointWithExt, goModAbsPathDir);
-    if (!analyzedRaw) {
-        throw new Error(`Could not find an exported function in "${entrypointWithExt}"
-Learn more: https://vercel.com/docs/runtimes#official-runtimes/go`);
-    }
-    const analyzed = JSON.parse(analyzedRaw);
+    const { goModPath } = await findGoModPath(path_1.join(workPath, entrypointDir), workPath);
+    const modulePath = goModPath ? path_1.dirname(goModPath) : undefined;
+    const analyzed = await go_helpers_1.getAnalyzedEntrypoint({
+        entrypoint: entrypointWithExt,
+        modulePath,
+        workPath,
+    });
     await Promise.all([
         copyEntrypoint(entrypointWithExt, tmpPackage),
         copyDevServer(analyzed.functionName, tmpPackage),
-        goModAbsPathDir ? null : writeDefaultGoMod(tmp, analyzed.packageName),
+        writeGoMod({
+            destDir: tmp,
+            goModPath,
+            packageName: analyzed.packageName,
+        }),
+        writeGoWork(tmp, workPath, modulePath),
     ]);
     const portFile = path_1.join(TMP, `vercel-dev-port-${Math.random().toString(32).substring(2)}`);
     const env = build_utils_1.cloneEnv(process.env, meta.env, {
@@ -23462,7 +24588,7 @@ Learn more: https://vercel.com/docs/runtimes#official-runtimes/go`);
     // more info.
     // build the dev server
     const go = await go_helpers_1.createGo({
-        modulePath: goModAbsPathDir,
+        modulePath,
         opts: {
             cwd: tmp,
             env,
@@ -23554,7 +24680,7 @@ async function prepareCache({ workPath, }) {
     //
     // On the next build, the local cache will be restored and `createGo()` will
     // use it unless the preferred Go version changed in the `go.mod`.
-    const goCacheDir = path_1.join(workPath, go_helpers_1.cacheDir);
+    const goCacheDir = path_1.join(workPath, go_helpers_1.localCacheDir);
     const stat = await fs_extra_1.lstat(goCacheDir);
     if (stat.isSymbolicLink()) {
         const goGlobalCacheDir = await fs_extra_1.readlink(goCacheDir);
@@ -23562,7 +24688,7 @@ async function prepareCache({ workPath, }) {
         await fs_extra_1.unlink(goCacheDir);
         await fs_extra_1.move(goGlobalCacheDir, goCacheDir);
     }
-    const cache = await build_utils_1.glob(`${go_helpers_1.cacheDir}/**`, workPath);
+    const cache = await build_utils_1.glob(`${go_helpers_1.localCacheDir}/**`, workPath);
     return cache;
 }
 exports.prepareCache = prepareCache;