@vercel/go 10.0.1 → 10.1.0

package/dist/index.js

@@ -164,12 +164,12 @@ var require_isexe = __commonJS({
         if (typeof Promise !== "function") {
           throw new TypeError("callback not provided");
         }
-        return new Promise(function(resolve, reject) {
+        return new Promise(function(resolve2, reject) {
           isexe(path, options || {}, function(er2, is2) {
             if (er2) {
               reject(er2);
             } else {
-              resolve(is2);
+              resolve2(is2);
             }
           });
         });
@@ -2069,7 +2069,7 @@ var require_get_stream = __commonJS({
       options = Object.assign({ maxBuffer: Infinity }, options);
       const { maxBuffer } = options;
       let stream;
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         const rejectPromise = (error) => {
           if (error) {
             error.bufferedData = stream.getBufferedValue();
@@ -2081,7 +2081,7 @@ var require_get_stream = __commonJS({
             rejectPromise(error);
             return;
           }
-          resolve();
+          resolve2();
         });
         stream.on("data", () => {
           if (stream.getBufferedLength() > maxBuffer) {
@@ -2105,11 +2105,11 @@ var require_p_finally = __commonJS({
       onFinally = onFinally || (() => {
       });
       return promise.then(
-        (val) => new Promise((resolve) => {
-          resolve(onFinally());
+        (val) => new Promise((resolve2) => {
+          resolve2(onFinally());
         }).then(() => val),
-        (err) => new Promise((resolve) => {
-          resolve(onFinally());
+        (err) => new Promise((resolve2) => {
+          resolve2(onFinally());
         }).then(() => {
           throw err;
         })
@@ -2488,8 +2488,8 @@ var require_execa = __commonJS({
       }
       let ret;
       if (!buffer) {
-        ret = new Promise((resolve, reject) => {
-          process2[stream].once("end", resolve).once("error", reject);
+        ret = new Promise((resolve2, reject) => {
+          process2[stream].once("end", resolve2).once("error", reject);
         });
       } else if (encoding) {
         ret = _getStream(process2[stream], {
@@ -2578,19 +2578,19 @@ ${stderr}${stdout}`;
           spawned.kill(parsed.opts.killSignal);
         }, parsed.opts.timeout);
       }
-      const processDone = new Promise((resolve) => {
+      const processDone = new Promise((resolve2) => {
         spawned.on("exit", (code, signal) => {
           cleanup();
-          resolve({ code, signal });
+          resolve2({ code, signal });
         });
         spawned.on("error", (err) => {
           cleanup();
-          resolve({ error: err });
+          resolve2({ error: err });
         });
         if (spawned.stdin) {
           spawned.stdin.on("error", (err) => {
             cleanup();
-            resolve({ error: err });
+            resolve2({ error: err });
           });
         }
       });
@@ -2907,7 +2907,7 @@ var require_lib = __commonJS({
   "../../node_modules/.pnpm/async-retry@1.3.3/node_modules/async-retry/lib/index.js"(exports, module2) {
     var retrier = require_retry2();
     function retry2(fn2, opts) {
-      function run(resolve, reject) {
+      function run(resolve2, reject) {
         var options = opts || {};
         var op;
         if (!("randomize" in options)) {
@@ -2936,7 +2936,7 @@ var require_lib = __commonJS({
             onError(err, num);
             return;
           }
-          Promise.resolve(val).then(resolve).catch(function catchIt(err) {
+          Promise.resolve(val).then(resolve2).catch(function catchIt(err) {
             onError(err, num);
           });
         }
@@ -2963,7 +2963,7 @@ var require_dist = __commonJS({
     (function(once3) {
       function spread(emitter, name) {
         let c = null;
-        const p2 = new Promise((resolve, reject) => {
+        const p2 = new Promise((resolve2, reject) => {
           function cancel() {
             emitter.removeListener(name, onEvent);
             emitter.removeListener("error", onError);
@@ -2971,7 +2971,7 @@ var require_dist = __commonJS({
           }
           function onEvent(...args) {
             cancel();
-            resolve(args);
+            resolve2(args);
           }
           function onError(err) {
             cancel();
@@ -3002,11 +3002,11 @@ var require_universalify = __commonJS({
         if (typeof arguments[arguments.length - 1] === "function")
           fn2.apply(this, arguments);
         else {
-          return new Promise((resolve, reject) => {
+          return new Promise((resolve2, reject) => {
             arguments[arguments.length] = (err, res) => {
               if (err)
                 return reject(err);
-              resolve(res);
+              resolve2(res);
             };
             arguments.length++;
             fn2.apply(this, arguments);
@@ -3096,7 +3096,7 @@ var require_polyfills = __commonJS({
       }
       if (platform === "win32") {
         fs3.rename = typeof fs3.rename !== "function" ? fs3.rename : function(fs$rename) {
-          function rename(from, to2, cb) {
+          function rename2(from, to2, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to2, function CB(er2) {
@@ -3118,8 +3118,8 @@ var require_polyfills = __commonJS({
             });
           }
           if (Object.setPrototypeOf)
-            Object.setPrototypeOf(rename, fs$rename);
-          return rename;
+            Object.setPrototypeOf(rename2, fs$rename);
+          return rename2;
         }(fs3.rename);
       }
       fs3.read = typeof fs3.read !== "function" ? fs3.read : function(fs$read) {
@@ -3889,19 +3889,19 @@ var require_fs = __commonJS({
       if (typeof callback === "function") {
         return fs3.exists(filename, callback);
       }
-      return new Promise((resolve) => {
-        return fs3.exists(filename, resolve);
+      return new Promise((resolve2) => {
+        return fs3.exists(filename, resolve2);
       });
     };
     exports.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
         return fs3.read(fd, buffer, offset, length, position, callback);
       }
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         fs3.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err)
             return reject(err);
-          resolve({ bytesRead, buffer: buffer2 });
+          resolve2({ bytesRead, buffer: buffer2 });
         });
       });
     };
@@ -3909,11 +3909,11 @@ var require_fs = __commonJS({
       if (typeof args[args.length - 1] === "function") {
         return fs3.write(fd, buffer, ...args);
       }
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         fs3.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err)
             return reject(err);
-          resolve({ bytesWritten, buffer: buffer2 });
+          resolve2({ bytesWritten, buffer: buffer2 });
         });
       });
     };
@@ -5194,11 +5194,11 @@ var require_symlink = __commonJS({
           return callback(err);
         if (destinationExists)
           return callback(null);
-        symlinkPaths(srcpath, dstpath, (err2, relative2) => {
+        symlinkPaths(srcpath, dstpath, (err2, relative4) => {
           if (err2)
             return callback(err2);
-          srcpath = relative2.toDst;
-          symlinkType(relative2.toCwd, type, (err3, type2) => {
+          srcpath = relative4.toDst;
+          symlinkType(relative4.toCwd, type, (err3, type2) => {
             if (err3)
               return callback(err3);
             const dir = path.dirname(dstpath);
@@ -5221,9 +5221,9 @@ var require_symlink = __commonJS({
       const destinationExists = fs3.existsSync(dstpath);
       if (destinationExists)
         return void 0;
-      const relative2 = symlinkPathsSync(srcpath, dstpath);
-      srcpath = relative2.toDst;
-      type = symlinkTypeSync(relative2.toCwd, type);
+      const relative4 = symlinkPathsSync(srcpath, dstpath);
+      srcpath = relative4.toDst;
+      type = symlinkTypeSync(relative4.toCwd, type);
       const dir = path.dirname(dstpath);
       const exists = fs3.existsSync(dir);
       if (exists)
@@ -5244,7 +5244,7 @@ var require_ensure = __commonJS({
     "use strict";
     var file = require_file();
     var link = require_link();
-    var symlink2 = require_symlink();
+    var symlink3 = require_symlink();
     module2.exports = {
       // file
       createFile: file.createFile,
@@ -5257,10 +5257,10 @@ var require_ensure = __commonJS({
       ensureLink: link.createLink,
       ensureLinkSync: link.createLinkSync,
       // symlink
-      createSymlink: symlink2.createSymlink,
-      createSymlinkSync: symlink2.createSymlinkSync,
-      ensureSymlink: symlink2.createSymlink,
-      ensureSymlinkSync: symlink2.createSymlinkSync
+      createSymlink: symlink3.createSymlink,
+      createSymlinkSync: symlink3.createSymlinkSync,
+      ensureSymlink: symlink3.createSymlink,
+      ensureSymlinkSync: symlink3.createSymlinkSync
     };
   }
 });
@@ -5605,7 +5605,7 @@ var require_move = __commonJS({
         return remove4(dest, (err) => {
           if (err)
             return cb(err);
-          return rename(src, dest, overwrite, cb);
+          return rename2(src, dest, overwrite, cb);
         });
       }
       pathExists5(dest, (err, destExists) => {
@@ -5613,10 +5613,10 @@ var require_move = __commonJS({
           return cb(err);
         if (destExists)
           return cb(new Error("dest already exists."));
-        return rename(src, dest, overwrite, cb);
+        return rename2(src, dest, overwrite, cb);
       });
     }
-    function rename(src, dest, overwrite, cb) {
+    function rename2(src, dest, overwrite, cb) {
       fs3.rename(src, dest, (err) => {
         if (!err)
           return cb();
@@ -7791,7 +7791,7 @@ var require_lib4 = __commonJS({
       let accum = [];
       let accumBytes = 0;
       let abort = false;
-      return new Body.Promise(function(resolve, reject) {
+      return new Body.Promise(function(resolve2, reject) {
         let resTimeout;
         if (_this4.timeout) {
           resTimeout = setTimeout(function() {
@@ -7825,7 +7825,7 @@ var require_lib4 = __commonJS({
           }
           clearTimeout(resTimeout);
           try {
-            resolve(Buffer.concat(accum, accumBytes));
+            resolve2(Buffer.concat(accum, accumBytes));
           } catch (err) {
             reject(new FetchError(`Could not create Buffer from response body for ${_this4.url}: ${err.message}`, "system", err));
           }
@@ -8505,7 +8505,7 @@ var require_lib4 = __commonJS({
         throw new Error("native promise missing, set fetch.Promise to your favorite alternative");
       }
       Body.Promise = fetch.Promise;
-      return new fetch.Promise(function(resolve, reject) {
+      return new fetch.Promise(function(resolve2, reject) {
         const request = new Request(url, opts);
         const options = getNodeRequestOptions(request);
         const send = (options.protocol === "https:" ? https : http).request;
@@ -8640,7 +8640,7 @@ var require_lib4 = __commonJS({
                   requestOpts.body = void 0;
                   requestOpts.headers.delete("content-length");
                 }
-                resolve(fetch(new Request(locationURL, requestOpts)));
+                resolve2(fetch(new Request(locationURL, requestOpts)));
                 finalize();
                 return;
             }
@@ -8662,7 +8662,7 @@ var require_lib4 = __commonJS({
           const codings = headers.get("Content-Encoding");
           if (!request.compress || request.method === "HEAD" || codings === null || res.statusCode === 204 || res.statusCode === 304) {
             response = new Response(body, response_options);
-            resolve(response);
+            resolve2(response);
             return;
           }
           const zlibOptions = {
@@ -8672,7 +8672,7 @@ var require_lib4 = __commonJS({
           if (codings == "gzip" || codings == "x-gzip") {
             body = body.pipe(zlib.createGunzip(zlibOptions));
             response = new Response(body, response_options);
-            resolve(response);
+            resolve2(response);
             return;
           }
           if (codings == "deflate" || codings == "x-deflate") {
@@ -8684,12 +8684,12 @@ var require_lib4 = __commonJS({
                 body = body.pipe(zlib.createInflateRaw());
               }
               response = new Response(body, response_options);
-              resolve(response);
+              resolve2(response);
             });
             raw.on("end", function() {
               if (!response) {
                 response = new Response(body, response_options);
-                resolve(response);
+                resolve2(response);
               }
             });
             return;
@@ -8697,11 +8697,11 @@ var require_lib4 = __commonJS({
           if (codings == "br" && typeof zlib.createBrotliDecompress === "function") {
             body = body.pipe(zlib.createBrotliDecompress());
             response = new Response(body, response_options);
-            resolve(response);
+            resolve2(response);
             return;
           }
           response = new Response(body, response_options);
-          resolve(response);
+          resolve2(response);
         });
         writeToStream(req, request);
       });
@@ -10463,18 +10463,18 @@ var require_promisify = __commonJS({
       const fromBuffer = fnName == "fromBuffer";
       cloner.patch(yauzl2, fnName, (original) => {
         return function(path, totalSize, options) {
-          return new Promise2((resolve, reject) => {
+          return new Promise2((resolve2, reject) => {
             options = Object.assign({}, options, { lazyEntries: true, autoClose: false });
             original(path, totalSize, options, (err, zipFile) => {
               if (err)
                 return reject(err);
-              opened(zipFile, resolve, fromBuffer, yauzl2);
+              opened(zipFile, resolve2, fromBuffer, yauzl2);
             });
           });
         };
       });
     }
-    function opened(zipFile, resolve, fromBuffer, yauzl2) {
+    function opened(zipFile, resolve2, fromBuffer, yauzl2) {
       if (fromBuffer) {
         zipFile.reader.unref = yauzl2.RandomAccessReader.prototype.unref;
         zipFile.reader.close = (cb) => cb();
@@ -10485,7 +10485,7 @@ var require_promisify = __commonJS({
       zipFile.intercept("end", emittedEnd);
       zipFile.intercept("close", emittedClose);
       zipFile.intercept("error", emittedError);
-      resolve(zipFile);
+      resolve2(zipFile);
     }
     function emittedError(err) {
       const state = getState(this);
@@ -10504,14 +10504,14 @@ var require_promisify = __commonJS({
     function promisifyClose(ZipFile, Promise2) {
       const close = ZipFile.prototype.close;
       ZipFile.prototype.close = function() {
-        return new Promise2((resolve, reject) => {
+        return new Promise2((resolve2, reject) => {
           if (getError(this))
             return rejectWithStoredError(this, reject);
           if (!this.isOpen)
-            return resolve();
+            return resolve2();
           if (getState(this))
             return reject(new Error("Previous operation has not completed yet"));
-          setState(this, { action: "close", resolve, reject });
+          setState(this, { action: "close", resolve: resolve2, reject });
           close.call(this);
         });
       };
@@ -10526,14 +10526,14 @@ var require_promisify = __commonJS({
     function promisifyReadEntry(ZipFile, Promise2) {
       const readEntry = ZipFile.prototype.readEntry;
       ZipFile.prototype.readEntry = function() {
-        return new Promise2((resolve, reject) => {
+        return new Promise2((resolve2, reject) => {
           if (getError(this))
             return rejectWithStoredError(this, reject);
           if (!this.isOpen)
             return reject(new Error("ZipFile is not open"));
           if (getState(this))
             return reject(new Error("Previous operation has not completed yet"));
-          setState(this, { action: "read", resolve, reject });
+          setState(this, { action: "read", resolve: resolve2, reject });
           readEntry.call(this);
         });
       };
@@ -10579,11 +10579,11 @@ var require_promisify = __commonJS({
     function addWalkEntriesMethod(ZipFile, Promise2) {
       ZipFile.prototype.walkEntries = function(callback, numEntries) {
         callback = wrapFunctionToReturnPromise(callback, Promise2);
-        return new Promise2((resolve, reject) => {
+        return new Promise2((resolve2, reject) => {
           walkNextEntry(this, callback, numEntries, 0, (err) => {
             if (err)
               return reject(err);
-            resolve();
+            resolve2();
           });
         });
       };
@@ -10604,13 +10604,13 @@ var require_promisify = __commonJS({
     function promisifyOpenReadStream(ZipFile, Promise2) {
       const openReadStream = ZipFile.prototype.openReadStream;
       ZipFile.prototype.openReadStream = function(entry, options) {
-        return new Promise2((resolve, reject) => {
+        return new Promise2((resolve2, reject) => {
           if (getError(this))
             return rejectWithStoredError(this, reject);
           openReadStream.call(this, entry, options || {}, (err, stream) => {
             if (err)
               return reject(err);
-            resolve(stream);
+            resolve2(stream);
           });
         });
       };
@@ -10626,7 +10626,7 @@ var require_promisify = __commonJS({
             return result;
           return Promise2.resolve(result);
         } catch (err) {
-          return new Promise2((resolve, reject) => {
+          return new Promise2((resolve2, reject) => {
             reject(err);
           });
         }
@@ -11045,7 +11045,7 @@ var require_dev_proxy = __commonJS({
       return sanitized;
     }
     function findFreePort() {
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         const server = (0, import_node_net.createServer)();
         server.unref();
         server.once("error", reject);
@@ -11056,17 +11056,17 @@ var require_dev_proxy = __commonJS({
             return;
           }
           const { port } = address;
-          server.close(() => resolve(port));
+          server.close(() => resolve2(port));
         });
       });
     }
     function isPortReachable(port) {
-      return new Promise((resolve) => {
+      return new Promise((resolve2) => {
         const socket = (0, import_node_net.createConnection)({ port, host: LOCALHOST });
         const done = (reachable) => {
           socket.removeAllListeners();
           socket.destroy();
-          resolve(reachable);
+          resolve2(reachable);
         };
         socket.setTimeout(READINESS_DIAL_TIMEOUT);
         socket.once("connect", () => done(true));
@@ -11075,7 +11075,7 @@ var require_dev_proxy = __commonJS({
       });
     }
     function sleep(ms2) {
-      return new Promise((resolve) => setTimeout(resolve, ms2));
+      return new Promise((resolve2) => setTimeout(resolve2, ms2));
     }
     async function waitForPort(port, child, timeout, label = "Dev server") {
       let exited;
@@ -11188,8 +11188,8 @@ var require_dev_proxy = __commonJS({
       let server;
       const close = async () => {
         if (server) {
-          await new Promise((resolve) => {
-            server?.close(() => resolve());
+          await new Promise((resolve2) => {
+            server?.close(() => resolve2());
             server?.closeAllConnections?.();
           });
         }
@@ -11204,9 +11204,9 @@ var require_dev_proxy = __commonJS({
           routePrefix: resolveServiceRoutePrefix(env)
         });
         const listenPort = options.port ?? await findFreePort();
-        await new Promise((resolve, reject) => {
+        await new Promise((resolve2, reject) => {
           server?.once("error", reject);
-          server?.listen(listenPort, () => resolve());
+          server?.listen(listenPort, () => resolve2());
         });
         if (!child.pid) {
           throw new Error(`${label} started without a PID`);
@@ -14555,7 +14555,8 @@ var import_yauzl_promise = __toESM(require_lib6());
 var import_xdg_app_paths = __toESM(require_xdg_app_paths());
 var streamPipeline = (0, import_util.promisify)(import_stream.pipeline);
 var versionMap = /* @__PURE__ */ new Map([
-  ["1.26", "1.26.1"],
+  ["1.27", "1.27.1"],
+  ["1.26", "1.26.8"],
   ["1.25", "1.25.8"],
   ["1.24", "1.24.13"],
   ["1.23", "1.23.12"],
@@ -14680,13 +14681,14 @@ Learn more: https://vercel.com/docs/functions/serverless-functions/runtimes/go
   return JSON.parse(analyzed);
 }
 var GoWrapper = class {
-  constructor(env, opts = {}, resolvedVersion) {
+  constructor(env, opts = {}, resolvedVersion, versionSource = { kind: "default" }) {
     if (!opts.cwd) {
       opts.cwd = process.cwd();
     }
     this.env = env;
     this.opts = opts;
     this.resolvedVersion = resolvedVersion;
+    this.versionSource = versionSource;
   }
   async execute(...args) {
     const { opts, env } = this;
@@ -14771,6 +14773,40 @@ var GoWrapper = class {
 function newestSupportedGoVersion() {
   return Array.from(versionMap.values())[0];
 }
+async function findFileInAncestors(startDir, stopDir, filename) {
+  let dir = (0, import_path4.resolve)(startDir);
+  const boundary = (0, import_path4.resolve)(stopDir);
+  const fromBoundary = (0, import_path4.relative)(boundary, dir);
+  if (fromBoundary === ".." || fromBoundary.startsWith(`..${import_path4.sep}`) || (0, import_path4.isAbsolute)(fromBoundary)) {
+    return void 0;
+  }
+  let reachedTop = false;
+  while (!reachedTop) {
+    const candidate = (0, import_path4.join)(dir, filename);
+    if (await (0, import_fs_extra.pathExists)(candidate)) {
+      (0, import_build_utils.debug)(`Found ${candidate}`);
+      return candidate;
+    }
+    const parent = (0, import_path4.dirname)(dir);
+    reachedTop = (0, import_path4.relative)(boundary, dir) === "" || parent === dir;
+    dir = parent;
+  }
+  return void 0;
+}
+function findGoModPath(startDir, stopDir) {
+  return findFileInAncestors(startDir, stopDir, "go.mod");
+}
+async function findGoWorkPath(startDir, stopDir, goWork) {
+  if (goWork === "off")
+    return void 0;
+  if (goWork && goWork !== "auto") {
+    if (!(0, import_path4.isAbsolute)(goWork)) {
+      throw new Error("GOWORK must be an absolute path");
+    }
+    return goWork;
+  }
+  return findFileInAncestors(startDir, stopDir, "go.work");
+}
 function compareGoVersions(left, right) {
   const leftParts = left.split(".").map((part) => parseInt(part, 10));
   const rightParts = right.split(".").map((part) => parseInt(part, 10));
@@ -14805,22 +14841,58 @@ function isBelowMinDarwinRunnable(version2) {
   }
   return minor < MIN_DARWIN_RUNNABLE_GO.minor;
 }
+async function getInstalledGoVersion(env) {
+  const { stdout } = await (0, import_execa.default)("go", ["version"], {
+    env: { ...env, GOTOOLCHAIN: "local" },
+    extendEnv: false
+  });
+  return parseGoVersionString(stdout);
+}
+async function resolvePreferredGoVersion({
+  modulePath,
+  workspaceFile
+}) {
+  if (workspaceFile) {
+    const versions = await parseGoVersionFile(workspaceFile);
+    if (versions) {
+      return { versions, file: workspaceFile, kind: "go.work" };
+    }
+  }
+  if (modulePath) {
+    const file = (0, import_path4.join)(modulePath, "go.mod");
+    const versions = await parseGoVersionFile(file);
+    if (versions) {
+      return { versions, file, kind: "go.mod" };
+    }
+  }
+  return void 0;
+}
 async function createGo({
   modulePath,
+  workspaceFile,
   opts = {},
   workPath,
   preferNewestToolchain = false
 }) {
-  let goPreferredVersion;
-  if (modulePath) {
-    goPreferredVersion = await parseGoModVersionFromModule(modulePath);
-  }
+  const preferred = await resolvePreferredGoVersion({
+    modulePath,
+    workspaceFile
+  });
+  const goPreferredVersion = preferred?.versions;
   const goSelectedVersion = selectGoVersion(goPreferredVersion, {
     preferNewestToolchain
   });
+  let versionSource = { kind: "default" };
+  if (preferred && preferred.versions.toolchain === goSelectedVersion) {
+    const { kind, file } = preferred;
+    versionSource = { kind, file, directive: "toolchain" };
+  } else if (preferred && preferred.versions.go === goSelectedVersion) {
+    const { kind, file } = preferred;
+    versionSource = { kind, file, directive: "go" };
+  }
   if (preferNewestToolchain && process.platform === "darwin" && isBelowMinDarwinRunnable(goSelectedVersion)) {
     console.warn(
-      `Warning: your \`go.mod\` pins Go ${goSelectedVersion} via \`toolchain\`. Binaries built with Go older than ${MIN_DARWIN_RUNNABLE_GO.major}.${MIN_DARWIN_RUNNABLE_GO.minor} do not start on recent macOS. Remove the directive to use Go ${newestSupportedGoVersion()} locally.`
+      `Warning: your \`${preferred?.kind ?? "go.mod"}\` pins Go ${goSelectedVersion} via \`toolchain\`. Binaries built with Go older than ${MIN_DARWIN_RUNNABLE_GO.major}.${MIN_DARWIN_RUNNABLE_GO.minor} do not start on recent macOS. Remove the directive to use Go ${newestSupportedGoVersion()} locally.`
     );
   }
   const env = opts.env ? (0, import_build_utils.cloneEnv)(opts.env) : (0, import_build_utils.cloneEnv)(process.env);
@@ -14831,8 +14903,8 @@ async function createGo({
     `${goSelectedVersion}_${platform}_${process.arch}`
   );
   const goCacheDir = (0, import_path4.join)(workPath, localCacheDir);
-  if (goPreferredVersion) {
-    (0, import_build_utils.debug)(`Preferred go version ${goSelectedVersion} (from go.mod)`);
+  if (preferred) {
+    (0, import_build_utils.debug)(`Preferred go version ${goSelectedVersion} (from ${preferred.file})`);
     env.GO111MODULE = "on";
   } else {
     (0, import_build_utils.debug)(
@@ -14900,18 +14972,14 @@ async function createGo({
       }
       env.GOROOT = goDir || void 0;
       env.PATH = goBinDir || PATH;
-      const { stdout } = await (0, import_execa.default)("go", ["version"], {
-        env,
-        extendEnv: false
-      });
-      const { major, minor, short, version: version2 } = parseGoVersionString(stdout);
+      const { major, minor, short, version: version2 } = await getInstalledGoVersion(env);
       if (major < GO_MIN_MAJOR_VERSION || major === GO_MIN_MAJOR_VERSION && minor < GO_MIN_MINOR_VERSION) {
         (0, import_build_utils.debug)(`Found go ${version2} in ${label}, but version is unsupported`);
       }
       if (version2 === goSelectedVersion || short === goSelectedVersion) {
         (0, import_build_utils.debug)(`Selected go ${version2} (from ${label})`);
         await setGoEnv(goDir);
-        return new GoWrapper(env, opts, version2);
+        return new GoWrapper(env, opts, version2, versionSource);
       } else {
         (0, import_build_utils.debug)(`Found go ${version2} in ${label}, but need ${goSelectedVersion}`);
       }
@@ -14924,7 +14992,7 @@ async function createGo({
     version: goSelectedVersion
   });
   await setGoEnv(goGlobalCacheDir);
-  return new GoWrapper(env, opts, goSelectedVersion);
+  return new GoWrapper(env, opts, goSelectedVersion, versionSource);
 }
 async function download({ dest, version: version2 }) {
   const { filename, url } = getGoUrl(version2);
@@ -14965,8 +15033,8 @@ async function download({ dest, version: version2 }) {
         await (0, import_fs_extra.remove)(zipFile);
       }
     } else {
-      await new Promise((resolve, reject) => {
-        res.body.on("error", reject).pipe(lo({ cwd: tmpDest, strip: 1 })).on("error", reject).on("finish", resolve);
+      await new Promise((resolve2, reject) => {
+        res.body.on("error", reject).pipe(lo({ cwd: tmpDest, strip: 1 })).on("error", reject).on("finish", resolve2);
       });
     }
     await import_fs5.default.promises.writeFile((0, import_path4.join)(tmpDest, GO_INSTALL_MARKER), version2);
@@ -15000,9 +15068,8 @@ function parseGoVersionString(goVersionOutput) {
 }
 var GoError = class extends Error {
 };
-async function parseGoModVersionFromModule(modulePath) {
+async function parseGoVersionFile(file) {
   let version2;
-  const file = (0, import_path4.join)(modulePath, "go.mod");
   try {
     const content = await (0, import_fs_extra.readFile)(file, "utf8");
     version2 = parseGoModVersion(content);
@@ -15124,6 +15191,12 @@ function parseGoModVersion(content) {
         toolchain
       };
     }
+    if (major === GO_MIN_MAJOR_VERSION && compareGoVersions(`${major}.${minor}`, newestSupportedGoVersion()) > 0) {
+      return {
+        go: `${major}.${minor}.0`,
+        toolchain
+      };
+    }
   }
   const err = new GoError(`Unsupported Go version ${major}.${minor}`);
   err.code = "ERR_UNSUPPORTED_GO_VERSION";
@@ -15276,25 +15349,42 @@ function getStandaloneServerRoutes(service) {
     }
   ];
 }
-async function findGoModPath(entrypointDir, workPath) {
-  let goModPath = void 0;
-  let isGoModInRootDir = false;
-  let dir = entrypointDir;
-  while (!isGoModInRootDir) {
-    isGoModInRootDir = dir === workPath;
-    const goMod = (0, import_path6.join)(dir, "go.mod");
-    if (await (0, import_fs_extra3.pathExists)(goMod)) {
-      goModPath = goMod;
-      (0, import_build_utils4.debug)(`Found ${goModPath}"`);
-      break;
-    }
-    dir = (0, import_path6.dirname)(dir);
-  }
+async function locateGoModule({
+  entrypoint,
+  workPath,
+  repoRootPath,
+  goWork
+}) {
+  const entrypointDir = (0, import_path6.dirname)((0, import_path6.join)(workPath, entrypoint));
+  const repoRoot = repoRootPath ?? workPath;
+  const [goModPath, goWorkPath] = await Promise.all([
+    findGoModPath(entrypointDir, repoRoot),
+    findGoWorkPath(workPath, repoRoot, goWork)
+  ]);
   return {
     goModPath,
-    isGoModInRootDir
+    modulePath: goModPath ? (0, import_path6.dirname)(goModPath) : workPath,
+    workspaceFile: goWorkPath,
+    repoRoot
   };
 }
+function describeGoVersion(go, repoRoot) {
+  const { versionSource } = go;
+  if (versionSource.kind === "default") {
+    return `Using Go ${go.resolvedVersion} (default)`;
+  }
+  const file = (0, import_path6.relative)(repoRoot, versionSource.file) || versionSource.kind;
+  const via = versionSource.directive === "toolchain" ? " via `toolchain` directive" : "";
+  return `Using Go ${go.resolvedVersion} (from ${file}${via})`;
+}
+function logGoVersion(go, repoRoot, entrypoint) {
+  console.log(describeGoVersion(go, repoRoot));
+  if (go.versionSource.kind === "default") {
+    console.log(
+      `Warning: no go.mod or go.work found for ${entrypoint} (searched up to ${repoRoot}). Add a \`go\` directive to pin the toolchain version.`
+    );
+  }
+}
 async function buildStandaloneServer(options) {
   const lambda = await createStandaloneServerLambda(options);
   const { service } = options;
@@ -15314,6 +15404,7 @@ async function createStandaloneServerLambda({
   entrypoint,
   config,
   workPath,
+  repoRootPath,
   meta = {},
   registerPreDeploy,
   service
@@ -15330,13 +15421,19 @@ async function createStandaloneServerLambda({
     GOOS: "linux",
     CGO_ENABLED: "0"
   });
-  const { goModPath } = await findGoModPath(workPath, workPath);
-  const modulePath = goModPath ? (0, import_path6.dirname)(goModPath) : workPath;
+  const { goModPath, modulePath, workspaceFile, repoRoot } = await locateGoModule({
+    entrypoint,
+    workPath,
+    repoRootPath,
+    goWork: env.GOWORK
+  });
   const go = await createGo({
     modulePath,
+    workspaceFile,
     opts: { cwd: workPath, env },
     workPath
   });
+  logGoVersion(go, repoRoot, entrypoint);
   const outDir = await (0, import_build_utils4.getWriteableDirectory)();
   const userServerPath = (0, import_path6.join)(outDir, "user-server");
   const vendorModulesPath = (0, import_path6.join)(workPath, "vendor", "modules.txt");
@@ -15458,7 +15555,7 @@ function toDevServerResult(serverKey, handle) {
   };
 }
 async function startStandaloneDevServer(opts, resolvedEntrypoint) {
-  const { workPath, meta = {} } = opts;
+  const { workPath, repoRootPath, meta = {} } = opts;
   const { devCacheDir = (0, import_path6.join)(workPath, ".vercel", "cache") } = meta;
   const serverKey = `${workPath}::${resolvedEntrypoint}`;
   const existing = PERSISTENT_SERVERS.get(serverKey);
@@ -15472,11 +15569,15 @@ async function startStandaloneDevServer(opts, resolvedEntrypoint) {
   }
   const startPromise = (async () => {
     const env = (0, import_build_utils4.cloneEnv)(process.env, meta.env);
-    const entrypointDir = (0, import_path6.dirname)((0, import_path6.join)(workPath, resolvedEntrypoint));
-    const { goModPath } = await findGoModPath(entrypointDir, workPath);
-    const modulePath = goModPath ? (0, import_path6.dirname)(goModPath) : workPath;
+    const { modulePath, workspaceFile } = await locateGoModule({
+      entrypoint: resolvedEntrypoint,
+      workPath,
+      repoRootPath,
+      goWork: env.GOWORK
+    });
     const go = await createGo({
       modulePath,
+      workspaceFile,
       opts: { cwd: workPath, env },
       workPath,
       // The binary has to run on this machine, so don't downgrade.
@@ -16010,8 +16111,8 @@ async function cleanupFileSystem({
       await (0, import_fs_extra4.remove)(action.from);
     }
   }
-  for (const rename of functionRenames) {
-    await renameHandlerFunction(rename.fsPath, rename.from, rename.to);
+  for (const rename2 of functionRenames) {
+    await renameHandlerFunction(rename2.fsPath, rename2.from, rename2.to);
   }
   const undoDirectoryPromises = directoryCreation.map(async (directory) => {
     const contents = await (0, import_fs_extra4.readdir)(directory);
@@ -16276,10 +16377,10 @@ async function startDevServer(opts) {
   if (!isReadable(portPipe)) {
     throw new Error("File descriptor 3 is not readable");
   }
-  const onPort = new Promise((resolve) => {
+  const onPort = new Promise((resolve2) => {
     portPipe.setEncoding("utf8");
     portPipe.once("data", (d) => {
-      resolve({ port: Number(d) });
+      resolve2({ port: Number(d) });
     });
   });
   const onPortFile = waitForPortFile(portFile);
@@ -16310,7 +16411,7 @@ function waitForPortFile(portFile) {
 }
 async function waitForPortFile_(opts) {
   while (!opts.canceled) {
-    await new Promise((resolve) => setTimeout(resolve, 100));
+    await new Promise((resolve2) => setTimeout(resolve2, 100));
     try {
       const port = Number(await (0, import_fs_extra4.readFile)(opts.portFile, "ascii"));
       (0, import_async_retry.default)(() => (0, import_fs_extra4.remove)(opts.portFile)).catch((err) => {
@@ -16324,19 +16425,73 @@ async function waitForPortFile_(opts) {
     }
   }
 }
+var pendingGoCacheCopies = /* @__PURE__ */ new Map();
+async function removeStagedGoCache(path) {
+  const stat = await (0, import_fs_extra4.lstat)(path);
+  if (stat.isDirectory()) {
+    await (0, import_fs_extra4.chmod)(path, stat.mode | 448);
+    for (const entry of await (0, import_fs_extra4.readdir)(path)) {
+      await removeStagedGoCache((0, import_path7.join)(path, entry));
+    }
+  }
+  await (0, import_fs_extra4.remove)(path);
+}
+async function materializeGoCache(goCacheDir) {
+  let source;
+  let target;
+  try {
+    if (!(await (0, import_fs_extra4.lstat)(goCacheDir)).isSymbolicLink())
+      return;
+    target = await (0, import_fs_extra4.readlink)(goCacheDir);
+    source = await (0, import_fs_extra4.realpath)(goCacheDir);
+  } catch (err) {
+    if (err?.code === "ENOENT" || err?.code === "ENOTDIR")
+      return;
+    throw err;
+  }
+  const stagingDir = await (0, import_fs_extra4.mkdtemp)(`${goCacheDir}.tmp-`);
+  try {
+    (0, import_build_utils5.debug)(`Preparing cache by copying ${source} -> ${goCacheDir}`);
+    await (0, import_fs_extra4.copy)(source, stagingDir);
+    await (0, import_fs_extra4.unlink)(goCacheDir);
+    try {
+      await (0, import_fs_extra4.rename)(stagingDir, goCacheDir);
+    } catch (err) {
+      await (0, import_fs_extra4.symlink)(target, goCacheDir).catch(
+        (linkErr) => {
+          if (linkErr.code !== "EEXIST")
+            throw linkErr;
+        }
+      );
+      throw err;
+    }
+  } catch (err) {
+    await removeStagedGoCache(stagingDir).catch((cleanupErr) => {
+      (0, import_build_utils5.debug)(`Failed to remove Go cache staging directory: ${cleanupErr}`);
+    });
+    throw err;
+  }
+}
 async function prepareCache({
-  workPath
+  workPath,
+  repoRootPath
 }) {
+  const root = repoRootPath || workPath;
   const goCacheDir = (0, import_path7.join)(workPath, localCacheDir);
-  const stat = await (0, import_fs_extra4.lstat)(goCacheDir);
-  if (stat.isSymbolicLink()) {
-    const goGlobalCacheDir = await (0, import_fs_extra4.readlink)(goCacheDir);
-    (0, import_build_utils5.debug)(`Preparing cache by moving ${goGlobalCacheDir} -> ${goCacheDir}`);
-    await (0, import_fs_extra4.unlink)(goCacheDir);
-    await (0, import_fs_extra4.move)(goGlobalCacheDir, goCacheDir);
+  let copying = pendingGoCacheCopies.get(goCacheDir);
+  if (!copying) {
+    copying = materializeGoCache(goCacheDir);
+    pendingGoCacheCopies.set(goCacheDir, copying);
+  }
+  try {
+    await copying;
+  } finally {
+    if (pendingGoCacheCopies.get(goCacheDir) === copying) {
+      pendingGoCacheCopies.delete(goCacheDir);
+    }
   }
-  const cache = await (0, import_build_utils5.glob)(`${localCacheDir}/**`, workPath);
-  return cache;
+  const mountpoint = (0, import_path7.relative)(root, workPath) || void 0;
+  return (0, import_build_utils5.glob)(`${localCacheDir}/**`, workPath, mountpoint);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/go",
-  "version": "10.0.1",
+  "version": "10.1.0",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/go",
@@ -16,7 +16,7 @@
   ],
   "dependencies": {},
   "peerDependencies": {
-    "@vercel/build-utils": "14.9.1"
+    "@vercel/build-utils": "14.9.2"
   },
   "devDependencies": {
     "@tootallnate/once": "1.1.2",
@@ -35,7 +35,7 @@
     "vitest": "4.1.10",
     "xdg-app-paths": "5.1.0",
     "yauzl-promise": "2.1.3",
-    "@vercel/build-utils": "14.9.1",
+    "@vercel/build-utils": "14.9.2",
     "@vercel-internals/ipc-proxy": "1.0.0"
   },
   "scripts": {