@vercel/go 3.3.5 → 3.4.0

package/dist/index.js

@@ -450,15 +450,15 @@ var require_readShebang = __commonJS({
 var require_semver = __commonJS({
   "../../node_modules/.pnpm/semver@5.7.2/node_modules/semver/semver.js"(exports, module2) {
     exports = module2.exports = SemVer;
-    var debug3;
+    var debug5;
     if (typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
-      debug3 = function() {
+      debug5 = function() {
         var args = Array.prototype.slice.call(arguments, 0);
         args.unshift("SEMVER");
         console.log.apply(console, args);
       };
     } else {
-      debug3 = function() {
+      debug5 = function() {
       };
     }
     exports.SEMVER_SPEC_VERSION = "2.0.0";
@@ -567,7 +567,7 @@ var require_semver = __commonJS({
     var STAR = R++;
     src[STAR] = "(<|>)?=?\\s*\\*";
     for (i = 0; i < R; i++) {
-      debug3(i, src[i]);
+      debug5(i, src[i]);
       if (!re[i]) {
         re[i] = new RegExp(src[i]);
         safeRe[i] = new RegExp(makeSafeRe(src[i]));
@@ -634,7 +634,7 @@ var require_semver = __commonJS({
       if (!(this instanceof SemVer)) {
         return new SemVer(version2, options);
       }
-      debug3("SemVer", version2, options);
+      debug5("SemVer", version2, options);
       this.options = options;
       this.loose = !!options.loose;
       var m = version2.trim().match(options.loose ? safeRe[LOOSE] : safeRe[FULL]);
@@ -681,7 +681,7 @@ var require_semver = __commonJS({
       return this.version;
     };
     SemVer.prototype.compare = function(other) {
-      debug3("SemVer.compare", this.version, this.options, other);
+      debug5("SemVer.compare", this.version, this.options, other);
       if (!(other instanceof SemVer)) {
         other = new SemVer(other, this.options);
       }
@@ -708,7 +708,7 @@ var require_semver = __commonJS({
       do {
         var a = this.prerelease[i2];
         var b = other.prerelease[i2];
-        debug3("prerelease compare", i2, a, b);
+        debug5("prerelease compare", i2, a, b);
         if (a === void 0 && b === void 0) {
           return 0;
         } else if (b === void 0) {
@@ -962,7 +962,7 @@ var require_semver = __commonJS({
         return new Comparator(comp, options);
       }
       comp = comp.trim().split(/\s+/).join(" ");
-      debug3("comparator", comp, options);
+      debug5("comparator", comp, options);
       this.options = options;
       this.loose = !!options.loose;
       this.parse(comp);
@@ -971,7 +971,7 @@ var require_semver = __commonJS({
       } else {
         this.value = this.operator + this.semver.version;
       }
-      debug3("comp", this);
+      debug5("comp", this);
     }
     var ANY = {};
     Comparator.prototype.parse = function(comp) {
@@ -994,7 +994,7 @@ var require_semver = __commonJS({
       return this.value;
     };
     Comparator.prototype.test = function(version2) {
-      debug3("Comparator.test", version2, this.options.loose);
+      debug5("Comparator.test", version2, this.options.loose);
       if (this.semver === ANY) {
         return true;
       }
@@ -1077,9 +1077,9 @@ var require_semver = __commonJS({
       var loose = this.options.loose;
       var hr = loose ? safeRe[HYPHENRANGELOOSE] : safeRe[HYPHENRANGE];
       range = range.replace(hr, hyphenReplace);
-      debug3("hyphen replace", range);
+      debug5("hyphen replace", range);
       range = range.replace(safeRe[COMPARATORTRIM], comparatorTrimReplace);
-      debug3("comparator trim", range, safeRe[COMPARATORTRIM]);
+      debug5("comparator trim", range, safeRe[COMPARATORTRIM]);
       range = range.replace(safeRe[TILDETRIM], tildeTrimReplace);
       range = range.replace(safeRe[CARETTRIM], caretTrimReplace);
       var compRe = loose ? safeRe[COMPARATORLOOSE] : safeRe[COMPARATOR];
@@ -1119,15 +1119,15 @@ var require_semver = __commonJS({
       });
     }
     function parseComparator(comp, options) {
-      debug3("comp", comp, options);
+      debug5("comp", comp, options);
       comp = replaceCarets(comp, options);
-      debug3("caret", comp);
+      debug5("caret", comp);
       comp = replaceTildes(comp, options);
-      debug3("tildes", comp);
+      debug5("tildes", comp);
       comp = replaceXRanges(comp, options);
-      debug3("xrange", comp);
+      debug5("xrange", comp);
       comp = replaceStars(comp, options);
-      debug3("stars", comp);
+      debug5("stars", comp);
       return comp;
     }
     function isX(id) {
@@ -1141,7 +1141,7 @@ var require_semver = __commonJS({
     function replaceTilde(comp, options) {
       var r = options.loose ? safeRe[TILDELOOSE] : safeRe[TILDE];
       return comp.replace(r, function(_, M, m, p, pr) {
-        debug3("tilde", comp, _, M, m, p, pr);
+        debug5("tilde", comp, _, M, m, p, pr);
         var ret;
         if (isX(M)) {
           ret = "";
@@ -1150,12 +1150,12 @@ var require_semver = __commonJS({
         } else if (isX(p)) {
           ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
         } else if (pr) {
-          debug3("replaceTilde pr", pr);
+          debug5("replaceTilde pr", pr);
           ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
         } else {
           ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
         }
-        debug3("tilde return", ret);
+        debug5("tilde return", ret);
         return ret;
       });
     }
@@ -1165,10 +1165,10 @@ var require_semver = __commonJS({
       }).join(" ");
     }
     function replaceCaret(comp, options) {
-      debug3("caret", comp, options);
+      debug5("caret", comp, options);
       var r = options.loose ? safeRe[CARETLOOSE] : safeRe[CARET];
       return comp.replace(r, function(_, M, m, p, pr) {
-        debug3("caret", comp, _, M, m, p, pr);
+        debug5("caret", comp, _, M, m, p, pr);
         var ret;
         if (isX(M)) {
           ret = "";
@@ -1181,7 +1181,7 @@ var require_semver = __commonJS({
             ret = ">=" + M + "." + m + ".0 <" + (+M + 1) + ".0.0";
           }
         } else if (pr) {
-          debug3("replaceCaret pr", pr);
+          debug5("replaceCaret pr", pr);
           if (M === "0") {
             if (m === "0") {
               ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + m + "." + (+p + 1);
@@ -1192,7 +1192,7 @@ var require_semver = __commonJS({
             ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + (+M + 1) + ".0.0";
           }
         } else {
-          debug3("no pr");
+          debug5("no pr");
           if (M === "0") {
             if (m === "0") {
               ret = ">=" + M + "." + m + "." + p + " <" + M + "." + m + "." + (+p + 1);
@@ -1203,12 +1203,12 @@ var require_semver = __commonJS({
             ret = ">=" + M + "." + m + "." + p + " <" + (+M + 1) + ".0.0";
           }
         }
-        debug3("caret return", ret);
+        debug5("caret return", ret);
         return ret;
       });
     }
     function replaceXRanges(comp, options) {
-      debug3("replaceXRanges", comp, options);
+      debug5("replaceXRanges", comp, options);
       return comp.split(/\s+/).map(function(comp2) {
         return replaceXRange(comp2, options);
       }).join(" ");
@@ -1217,7 +1217,7 @@ var require_semver = __commonJS({
       comp = comp.trim();
       var r = options.loose ? safeRe[XRANGELOOSE] : safeRe[XRANGE];
       return comp.replace(r, function(ret, gtlt, M, m, p, pr) {
-        debug3("xRange", comp, ret, gtlt, M, m, p, pr);
+        debug5("xRange", comp, ret, gtlt, M, m, p, pr);
         var xM = isX(M);
         var xm = xM || isX(m);
         var xp = xm || isX(p);
@@ -1260,12 +1260,12 @@ var require_semver = __commonJS({
         } else if (xp) {
           ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
         }
-        debug3("xRange return", ret);
+        debug5("xRange return", ret);
         return ret;
       });
     }
     function replaceStars(comp, options) {
-      debug3("replaceStars", comp, options);
+      debug5("replaceStars", comp, options);
       return comp.trim().replace(safeRe[STAR], "");
     }
     function hyphenReplace($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) {
@@ -1313,7 +1313,7 @@ var require_semver = __commonJS({
       }
       if (version2.prerelease.length && !options.includePrerelease) {
         for (i2 = 0; i2 < set.length; i2++) {
-          debug3(set[i2].semver);
+          debug5(set[i2].semver);
           if (set[i2].semver === ANY) {
             continue;
           }
@@ -1658,7 +1658,7 @@ var require_cross_spawn = __commonJS({
     var cp = require("child_process");
     var parse4 = require_parse();
     var enoent = require_enoent();
-    function spawn2(command, args, options) {
+    function spawn3(command, args, options) {
       const parsed = parse4(command, args, options);
       const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
@@ -1670,8 +1670,8 @@ var require_cross_spawn = __commonJS({
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
     }
-    module2.exports = spawn2;
-    module2.exports.spawn = spawn2;
+    module2.exports = spawn3;
+    module2.exports.spawn = spawn3;
     module2.exports.sync = spawnSync;
     module2.exports._parse = parse4;
     module2.exports._enoent = enoent;
@@ -3453,13 +3453,13 @@ var require_clone = __commonJS({
       if (obj === null || typeof obj !== "object")
         return obj;
       if (obj instanceof Object)
-        var copy2 = { __proto__: getPrototypeOf(obj) };
+        var copy3 = { __proto__: getPrototypeOf(obj) };
       else
-        var copy2 = /* @__PURE__ */ Object.create(null);
+        var copy3 = /* @__PURE__ */ Object.create(null);
       Object.getOwnPropertyNames(obj).forEach(function(key) {
-        Object.defineProperty(copy2, key, Object.getOwnPropertyDescriptor(obj, key));
+        Object.defineProperty(copy3, key, Object.getOwnPropertyDescriptor(obj, key));
       });
-      return copy2;
+      return copy3;
     }
   }
 });
@@ -3490,11 +3490,11 @@ var require_graceful_fs = __commonJS({
         }
       });
     }
-    var debug3 = noop3;
+    var debug5 = noop3;
     if (util.debuglog)
-      debug3 = util.debuglog("gfs4");
+      debug5 = util.debuglog("gfs4");
     else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
-      debug3 = function() {
+      debug5 = function() {
         var m = util.format.apply(util, arguments);
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
@@ -3529,7 +3529,7 @@ var require_graceful_fs = __commonJS({
       }(fs11.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug3(fs11[gracefulQueue]);
+          debug5(fs11[gracefulQueue]);
           require("assert").equal(fs11[gracefulQueue].length, 0);
         });
       }
@@ -3549,8 +3549,8 @@ var require_graceful_fs = __commonJS({
       fs12.createReadStream = createReadStream;
       fs12.createWriteStream = createWriteStream2;
       var fs$readFile = fs12.readFile;
-      fs12.readFile = readFile3;
-      function readFile3(path8, options, cb) {
+      fs12.readFile = readFile4;
+      function readFile4(path8, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$readFile(path8, options, cb);
@@ -3566,8 +3566,8 @@ var require_graceful_fs = __commonJS({
         }
       }
       var fs$writeFile = fs12.writeFile;
-      fs12.writeFile = writeFile2;
-      function writeFile2(path8, data, options, cb) {
+      fs12.writeFile = writeFile3;
+      function writeFile3(path8, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$writeFile(path8, data, options, cb);
@@ -3782,7 +3782,7 @@ var require_graceful_fs = __commonJS({
       return fs12;
     }
     function enqueue(elem) {
-      debug3("ENQUEUE", elem[0].name, elem[1]);
+      debug5("ENQUEUE", elem[0].name, elem[1]);
       fs11[gracefulQueue].push(elem);
       retry2();
     }
@@ -3809,10 +3809,10 @@ var require_graceful_fs = __commonJS({
       var startTime = elem[3];
       var lastTime = elem[4];
       if (startTime === void 0) {
-        debug3("RETRY", fn.name, args);
+        debug5("RETRY", fn.name, args);
         fn.apply(null, args);
       } else if (Date.now() - startTime >= 6e4) {
-        debug3("TIMEOUT", fn.name, args);
+        debug5("TIMEOUT", fn.name, args);
         var cb = args.pop();
         if (typeof cb === "function")
           cb.call(null, err);
@@ -3821,7 +3821,7 @@ var require_graceful_fs = __commonJS({
         var sinceStart = Math.max(lastTime - startTime, 1);
         var desiredDelay = Math.min(sinceStart * 1.2, 100);
         if (sinceAttempt >= desiredDelay) {
-          debug3("RETRY", fn.name, args);
+          debug5("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
           fs11[gracefulQueue].push(elem);
@@ -4356,11 +4356,11 @@ var require_path_exists = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var fs11 = require_fs();
-    function pathExists3(path8) {
+    function pathExists5(path8) {
       return fs11.access(path8).then(() => true).catch(() => false);
     }
     module2.exports = {
-      pathExists: u(pathExists3),
+      pathExists: u(pathExists5),
       pathExistsSync: fs11.existsSync
     };
   }
@@ -4373,10 +4373,10 @@ var require_copy = __commonJS({
     var fs11 = require_graceful_fs();
     var path8 = require("path");
     var mkdirp3 = require_mkdirs2().mkdirs;
-    var pathExists3 = require_path_exists().pathExists;
+    var pathExists5 = require_path_exists().pathExists;
     var utimes = require_utimes().utimesMillis;
     var notExist = Symbol("notExist");
-    function copy2(src, dest, opts, cb) {
+    function copy3(src, dest, opts, cb) {
       if (typeof opts === "function" && !cb) {
         cb = opts;
         opts = {};
@@ -4403,7 +4403,7 @@ var require_copy = __commonJS({
     }
     function checkParentDir(destStat, src, dest, opts, cb) {
       const destParent = path8.dirname(dest);
-      pathExists3(destParent, (err, dirExists) => {
+      pathExists5(destParent, (err, dirExists) => {
         if (err)
           return cb(err);
         if (dirExists)
@@ -4602,7 +4602,7 @@ var require_copy = __commonJS({
         return cb(null, destStat);
       });
     }
-    module2.exports = copy2;
+    module2.exports = copy3;
   }
 });
 
@@ -4939,7 +4939,7 @@ var require_file = __commonJS({
     var path8 = require("path");
     var fs11 = require_graceful_fs();
     var mkdir2 = require_mkdirs2();
-    var pathExists3 = require_path_exists().pathExists;
+    var pathExists5 = require_path_exists().pathExists;
     function createFile2(file, callback) {
       function makeFile() {
         fs11.writeFile(file, "", (err) => {
@@ -4952,7 +4952,7 @@ var require_file = __commonJS({
         if (!err && stats.isFile())
           return callback();
         const dir = path8.dirname(file);
-        pathExists3(dir, (err2, dirExists) => {
+        pathExists5(dir, (err2, dirExists) => {
           if (err2)
             return callback(err2);
           if (dirExists)
@@ -4994,7 +4994,7 @@ var require_link = __commonJS({
     var path8 = require("path");
     var fs11 = require_graceful_fs();
     var mkdir2 = require_mkdirs2();
-    var pathExists3 = require_path_exists().pathExists;
+    var pathExists5 = require_path_exists().pathExists;
     function createLink(srcpath, dstpath, callback) {
       function makeLink(srcpath2, dstpath2) {
         fs11.link(srcpath2, dstpath2, (err) => {
@@ -5003,7 +5003,7 @@ var require_link = __commonJS({
           callback(null);
         });
       }
-      pathExists3(dstpath, (err, destinationExists) => {
+      pathExists5(dstpath, (err, destinationExists) => {
         if (err)
           return callback(err);
         if (destinationExists)
@@ -5014,7 +5014,7 @@ var require_link = __commonJS({
             return callback(err2);
           }
           const dir = path8.dirname(dstpath);
-          pathExists3(dir, (err3, dirExists) => {
+          pathExists5(dir, (err3, dirExists) => {
             if (err3)
               return callback(err3);
             if (dirExists)
@@ -5058,7 +5058,7 @@ var require_symlink_paths = __commonJS({
     "use strict";
     var path8 = require("path");
     var fs11 = require_graceful_fs();
-    var pathExists3 = require_path_exists().pathExists;
+    var pathExists5 = require_path_exists().pathExists;
     function symlinkPaths(srcpath, dstpath, callback) {
       if (path8.isAbsolute(srcpath)) {
         return fs11.lstat(srcpath, (err) => {
@@ -5074,7 +5074,7 @@ var require_symlink_paths = __commonJS({
       } else {
         const dstdir = path8.dirname(dstpath);
         const relativeToDst = path8.join(dstdir, srcpath);
-        return pathExists3(relativeToDst, (err, exists) => {
+        return pathExists5(relativeToDst, (err, exists) => {
           if (err)
             return callback(err);
           if (exists) {
@@ -5185,11 +5185,11 @@ var require_symlink = __commonJS({
     var _symlinkType = require_symlink_type();
     var symlinkType = _symlinkType.symlinkType;
     var symlinkTypeSync = _symlinkType.symlinkTypeSync;
-    var pathExists3 = require_path_exists().pathExists;
+    var pathExists5 = require_path_exists().pathExists;
     function createSymlink(srcpath, dstpath, type, callback) {
       callback = typeof type === "function" ? type : callback;
       type = typeof type === "function" ? false : type;
-      pathExists3(dstpath, (err, destinationExists) => {
+      pathExists5(dstpath, (err, destinationExists) => {
         if (err)
           return callback(err);
         if (destinationExists)
@@ -5202,7 +5202,7 @@ var require_symlink = __commonJS({
             if (err3)
               return callback(err3);
             const dir = path8.dirname(dstpath);
-            pathExists3(dir, (err4, dirExists) => {
+            pathExists5(dir, (err4, dirExists) => {
               if (err4)
                 return callback(err4);
               if (dirExists)
@@ -5274,7 +5274,7 @@ var require_jsonfile = __commonJS({
     } catch (_) {
       _fs = require("fs");
     }
-    function readFile3(file, options, callback) {
+    function readFile4(file, options, callback) {
       if (callback == null) {
         callback = options;
         options = {};
@@ -5343,7 +5343,7 @@ var require_jsonfile = __commonJS({
       var str = JSON.stringify(obj, options ? options.replacer : null, spaces);
       return str.replace(/\n/g, EOL) + EOL;
     }
-    function writeFile2(file, obj, options, callback) {
+    function writeFile3(file, obj, options, callback) {
       if (callback == null) {
         callback = options;
         options = {};
@@ -5373,9 +5373,9 @@ var require_jsonfile = __commonJS({
       return content;
     }
     var jsonfile = {
-      readFile: readFile3,
+      readFile: readFile4,
       readFileSync,
-      writeFile: writeFile2,
+      writeFile: writeFile3,
       writeFileSync
     };
     module2.exports = jsonfile;
@@ -5404,7 +5404,7 @@ var require_output_json = __commonJS({
     "use strict";
     var path8 = require("path");
     var mkdir2 = require_mkdirs2();
-    var pathExists3 = require_path_exists().pathExists;
+    var pathExists5 = require_path_exists().pathExists;
     var jsonFile = require_jsonfile2();
     function outputJson(file, data, options, callback) {
       if (typeof options === "function") {
@@ -5412,7 +5412,7 @@ var require_output_json = __commonJS({
         options = {};
       }
       const dir = path8.dirname(file);
-      pathExists3(dir, (err, itDoes) => {
+      pathExists5(dir, (err, itDoes) => {
         if (err)
           return callback(err);
         if (itDoes)
@@ -5573,10 +5573,10 @@ var require_move = __commonJS({
     var u = require_universalify().fromCallback;
     var fs11 = require_graceful_fs();
     var path8 = require("path");
-    var copy2 = require_copy2().copy;
+    var copy3 = require_copy2().copy;
     var remove3 = require_remove().remove;
     var mkdirp3 = require_mkdirs2().mkdirp;
-    var pathExists3 = require_path_exists().pathExists;
+    var pathExists5 = require_path_exists().pathExists;
     function move2(src, dest, opts, cb) {
       if (typeof opts === "function") {
         cb = opts;
@@ -5608,7 +5608,7 @@ var require_move = __commonJS({
           return rename(src, dest, overwrite, cb);
         });
       }
-      pathExists3(dest, (err, destExists) => {
+      pathExists5(dest, (err, destExists) => {
         if (err)
           return cb(err);
         if (destExists)
@@ -5630,7 +5630,7 @@ var require_move = __commonJS({
         overwrite,
         errorOnExist: true
       };
-      copy2(src, dest, opts, (err) => {
+      copy3(src, dest, opts, (err) => {
         if (err)
           return cb(err);
         return remove3(src, cb);
@@ -5657,14 +5657,14 @@ var require_output = __commonJS({
     var fs11 = require_graceful_fs();
     var path8 = require("path");
     var mkdir2 = require_mkdirs2();
-    var pathExists3 = require_path_exists().pathExists;
+    var pathExists5 = require_path_exists().pathExists;
     function outputFile(file, data, encoding, callback) {
       if (typeof encoding === "function") {
         callback = encoding;
         encoding = "utf8";
       }
       const dir = path8.dirname(file);
-      pathExists3(dir, (err, itDoes) => {
+      pathExists5(dir, (err, itDoes) => {
         if (err)
           return callback(err);
         if (itDoes)
@@ -10883,7 +10883,7 @@ __export(src_exports, {
   build: () => build,
   getNewHandlerFunctionName: () => getNewHandlerFunctionName,
   prepareCache: () => prepareCache,
-  shouldServe: () => import_build_utils2.shouldServe,
+  shouldServe: () => import_build_utils4.shouldServe,
   startDevServer: () => startDevServer,
   version: () => version
 });
@@ -10891,11 +10891,11 @@ module.exports = __toCommonJS(src_exports);
 var import_execa2 = __toESM(require_execa());
 var import_async_retry = __toESM(require_lib());
 var import_os2 = require("os");
-var import_child_process = require("child_process");
+var import_child_process2 = require("child_process");
 var import_once = __toESM(require_dist());
-var import_path5 = require("path");
-var import_fs_extra2 = __toESM(require_lib2());
-var import_build_utils2 = require("@vercel/build-utils");
+var import_path7 = require("path");
+var import_fs_extra4 = __toESM(require_lib2());
+var import_build_utils4 = require("@vercel/build-utils");
 
 // src/go-helpers.ts
 var import_crypto = require("crypto");
@@ -17114,53 +17114,206 @@ function parseGoModVersion(content) {
   throw err;
 }
 
+// src/entrypoint.ts
+var import_path5 = require("path");
+var import_fs_extra2 = __toESM(require_lib2());
+var import_build_utils2 = require("@vercel/build-utils");
+var GO_CANDIDATE_ENTRYPOINTS = [
+  "main.go",
+  "cmd/api/main.go",
+  "cmd/server/main.go"
+];
+async function detectGoEntrypoint(workPath, configuredEntrypoint) {
+  if (await (0, import_fs_extra2.pathExists)((0, import_path5.join)(workPath, configuredEntrypoint))) {
+    (0, import_build_utils2.debug)(`Using configured Go entrypoint: ${configuredEntrypoint}`);
+    return configuredEntrypoint;
+  }
+  for (const candidate of GO_CANDIDATE_ENTRYPOINTS) {
+    if (await (0, import_fs_extra2.pathExists)((0, import_path5.join)(workPath, candidate))) {
+      (0, import_build_utils2.debug)(`Detected Go entrypoint: ${candidate}`);
+      return candidate;
+    }
+  }
+  return null;
+}
+
+// src/standalone-server.ts
+var import_child_process = require("child_process");
+var import_path6 = require("path");
+var import_fs_extra3 = __toESM(require_lib2());
+var import_build_utils3 = require("@vercel/build-utils");
+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_utils3.debug)(`Found ${goModPath}"`);
+      break;
+    }
+    dir = (0, import_path6.dirname)(dir);
+  }
+  return {
+    goModPath,
+    isGoModInRootDir
+  };
+}
+async function buildStandaloneServer({
+  files,
+  entrypoint,
+  config,
+  workPath,
+  meta = {}
+}) {
+  (0, import_build_utils3.debug)(`Building standalone Go server: ${entrypoint}`);
+  await (0, import_build_utils3.download)(files, workPath, meta);
+  const lambdaOptions = await (0, import_build_utils3.getLambdaOptionsFromFunction)({
+    sourceFile: entrypoint,
+    config
+  });
+  const architecture = lambdaOptions?.architecture || "x86_64";
+  const env = (0, import_build_utils3.cloneEnv)(process.env, meta.env, {
+    GOARCH: architecture === "arm64" ? "arm64" : "amd64",
+    GOOS: "linux",
+    CGO_ENABLED: "0"
+  });
+  const { goModPath } = await findGoModPath(workPath, workPath);
+  const modulePath = goModPath ? (0, import_path6.dirname)(goModPath) : workPath;
+  const go = await createGo({
+    modulePath,
+    opts: { cwd: workPath, env },
+    workPath
+  });
+  const outDir = await (0, import_build_utils3.getWriteableDirectory)();
+  const userServerPath = (0, import_path6.join)(outDir, "user-server");
+  const bootstrapPath = (0, import_path6.join)(outDir, "executable");
+  const buildTarget = entrypoint === "main.go" ? "." : "./" + (0, import_path6.dirname)(entrypoint);
+  (0, import_build_utils3.debug)(
+    `Building user Go server (${architecture}): go build ${buildTarget} -> ${userServerPath}`
+  );
+  try {
+    await go.build(buildTarget, userServerPath);
+  } catch (err) {
+    console.error(`Failed to build standalone Go server: ${buildTarget}`);
+    throw err;
+  }
+  const bootstrapSrc = (0, import_path6.join)(__dirname, "../vc-init.go");
+  (0, import_build_utils3.debug)(`Building bootstrap wrapper: ${bootstrapSrc} -> ${bootstrapPath}`);
+  try {
+    const bootstrapBuildDir = await (0, import_build_utils3.getWriteableDirectory)();
+    const bootstrapGoFile = (0, import_path6.join)(bootstrapBuildDir, "main.go");
+    await (0, import_fs_extra3.copy)(bootstrapSrc, bootstrapGoFile);
+    const bootstrapGoMod = (0, import_path6.join)(bootstrapBuildDir, "go.mod");
+    await (0, import_fs_extra3.writeFile)(bootstrapGoMod, "module vc-init\n\ngo 1.21\n");
+    const bootstrapGo = await createGo({
+      modulePath: bootstrapBuildDir,
+      opts: { cwd: bootstrapBuildDir, env },
+      workPath: bootstrapBuildDir
+    });
+    await bootstrapGo.build(".", bootstrapPath);
+  } catch (err) {
+    console.error("Failed to build bootstrap wrapper");
+    throw err;
+  }
+  const includedFiles = {};
+  if (config && config.includeFiles) {
+    const patterns = Array.isArray(config.includeFiles) ? config.includeFiles : [config.includeFiles];
+    for (const pattern of patterns) {
+      const fsFiles = await (0, import_build_utils3.glob)(pattern, workPath);
+      for (const [assetName, asset] of Object.entries(fsFiles)) {
+        includedFiles[assetName] = asset;
+      }
+    }
+  }
+  const [userServerData, bootstrapData] = await Promise.all([
+    (0, import_fs_extra3.readFile)(userServerPath),
+    (0, import_fs_extra3.readFile)(bootstrapPath)
+  ]);
+  const lambda = new import_build_utils3.Lambda({
+    ...lambdaOptions,
+    files: {
+      ...includedFiles,
+      // Bootstrap is the main entrypoint (handles IPC protocol)
+      executable: new import_build_utils3.FileBlob({ mode: 493, data: bootstrapData }),
+      // User's server is spawned by bootstrap
+      "user-server": new import_build_utils3.FileBlob({ mode: 493, data: userServerData })
+    },
+    handler: "executable",
+    runtime: "executable",
+    supportsResponseStreaming: true,
+    architecture,
+    runtimeLanguage: "go"
+  });
+  return { output: lambda };
+}
+async function startStandaloneDevServer(opts, resolvedEntrypoint) {
+  const { workPath, meta = {} } = opts;
+  const port = Math.floor(Math.random() * (65535 - 49152) + 49152);
+  const env = (0, import_build_utils3.cloneEnv)(process.env, meta.env, {
+    PORT: String(port)
+  });
+  const runTarget = resolvedEntrypoint === "main.go" ? "." : "./" + (0, import_path6.dirname)(resolvedEntrypoint);
+  (0, import_build_utils3.debug)(
+    `Starting standalone Go dev server: go run ${runTarget} (port ${port})`
+  );
+  const child = (0, import_child_process.spawn)("go", ["run", runTarget], {
+    cwd: workPath,
+    env,
+    stdio: ["ignore", "inherit", "inherit"]
+  });
+  await new Promise((resolve) => setTimeout(resolve, 2e3));
+  return {
+    port,
+    pid: child.pid
+  };
+}
+
 // src/index.ts
 var TMP = (0, import_os2.tmpdir)();
 var MAIN_GO_FILENAME = "main__vc__go__.go";
 var HANDLER_FILENAME = `bootstrap${OUT_EXTENSION}`;
 async function initPrivateGit(credentials) {
-  const gitCredentialsPath = (0, import_path5.join)((0, import_os2.homedir)(), ".git-credentials");
+  const gitCredentialsPath = (0, import_path7.join)((0, import_os2.homedir)(), ".git-credentials");
   await (0, import_execa2.default)("git", [
     "config",
     "--global",
     "credential.helper",
     `store --file ${gitCredentialsPath}`
   ]);
-  await (0, import_fs_extra2.writeFile)(gitCredentialsPath, credentials);
+  await (0, import_fs_extra4.writeFile)(gitCredentialsPath, credentials);
 }
 function getRenamedEntrypoint(entrypoint) {
-  const filename = (0, import_path5.basename)(entrypoint);
+  const filename = (0, import_path7.basename)(entrypoint);
   if (filename.startsWith("[")) {
     const newEntrypoint = entrypoint.replace("/[", "/now-bracket[");
-    (0, import_build_utils2.debug)(`Renamed entrypoint from ${entrypoint} to ${newEntrypoint}`);
+    (0, import_build_utils4.debug)(`Renamed entrypoint from ${entrypoint} to ${newEntrypoint}`);
     return newEntrypoint;
   }
   return void 0;
 }
 var version = 3;
-async function build({
-  files,
-  entrypoint,
-  config,
-  workPath,
-  meta = {}
-}) {
-  const goPath = await (0, import_build_utils2.getWriteableDirectory)();
-  const srcPath = (0, import_path5.join)(goPath, "src", "lambda");
+async function build(options) {
+  const { files, config, workPath, meta = {} } = options;
+  let { entrypoint } = options;
+  const goPath = await (0, import_build_utils4.getWriteableDirectory)();
+  const srcPath = (0, import_path7.join)(goPath, "src", "lambda");
   const downloadPath = meta.skipDownload ? workPath : srcPath;
-  await (0, import_build_utils2.download)(files, downloadPath, meta);
+  await (0, import_build_utils4.download)(files, downloadPath, meta);
   const undo = {
     fileActions: [],
     directoryCreation: [],
     functionRenames: []
   };
-  const env = (0, import_build_utils2.cloneEnv)(process.env, meta.env, {
+  const env = (0, import_build_utils4.cloneEnv)(process.env, meta.env, {
     GOARCH: "amd64",
     GOOS: "linux"
   });
   try {
     if (env.GIT_CREDENTIALS) {
-      (0, import_build_utils2.debug)("Initialize Git credentials...");
+      (0, import_build_utils4.debug)("Initialize Git credentials...");
       await initPrivateGit(env.GIT_CREDENTIALS);
     }
     if (env.GO111MODULE) {
@@ -17175,28 +17328,41 @@ Manually assigning 'GO111MODULE' is not recommended.
   Learn more: https://github.com/golang/go/wiki/Modules
   `);
     }
-    const originalEntrypointAbsolute = (0, import_path5.join)(workPath, entrypoint);
+    if (config?.framework === "go" || config?.framework === "services") {
+      const resolvedEntrypoint = await detectGoEntrypoint(workPath, entrypoint);
+      if (!resolvedEntrypoint) {
+        throw new Error(
+          `No Go entrypoint found. Expected one of: ${GO_CANDIDATE_ENTRYPOINTS.join(", ")}`
+        );
+      }
+      (0, import_build_utils4.debug)(`Using standalone Go server mode for ${resolvedEntrypoint}`);
+      return buildStandaloneServer({
+        ...options,
+        entrypoint: resolvedEntrypoint
+      });
+    }
+    const originalEntrypointAbsolute = (0, import_path7.join)(workPath, entrypoint);
     const renamedEntrypoint = getRenamedEntrypoint(entrypoint);
     if (renamedEntrypoint) {
-      await (0, import_fs_extra2.move)((0, import_path5.join)(workPath, entrypoint), (0, import_path5.join)(workPath, renamedEntrypoint));
+      await (0, import_fs_extra4.move)((0, import_path7.join)(workPath, entrypoint), (0, import_path7.join)(workPath, renamedEntrypoint));
       undo.fileActions.push({
-        to: (0, import_path5.join)(workPath, entrypoint),
-        from: (0, import_path5.join)(workPath, renamedEntrypoint)
+        to: (0, import_path7.join)(workPath, entrypoint),
+        from: (0, import_path7.join)(workPath, renamedEntrypoint)
       });
       entrypoint = renamedEntrypoint;
     }
-    const entrypointAbsolute = (0, import_path5.join)(workPath, entrypoint);
-    const entrypointDirname = (0, import_path5.dirname)(entrypointAbsolute);
-    const { goModPath, isGoModInRootDir } = await findGoModPath(
+    const entrypointAbsolute = (0, import_path7.join)(workPath, entrypoint);
+    const entrypointDirname = (0, import_path7.dirname)(entrypointAbsolute);
+    const { goModPath, isGoModInRootDir } = await findGoModPath2(
       entrypointDirname,
       workPath
     );
-    if (!goModPath && await (0, import_fs_extra2.pathExists)((0, import_path5.join)(workPath, "vendor"))) {
+    if (!goModPath && await (0, import_fs_extra4.pathExists)((0, import_path7.join)(workPath, "vendor"))) {
       throw new Error("`go.mod` is required to use a `vendor` directory.");
     }
     const analyzed = await getAnalyzedEntrypoint({
       entrypoint,
-      modulePath: goModPath ? (0, import_path5.dirname)(goModPath) : void 0,
+      modulePath: goModPath ? (0, import_path7.dirname)(goModPath) : void 0,
       workPath
     });
     const packageName = analyzed.packageName;
@@ -17222,13 +17388,13 @@ Manually assigning 'GO111MODULE' is not recommended.
     if (config && config.includeFiles) {
       const patterns = Array.isArray(config.includeFiles) ? config.includeFiles : [config.includeFiles];
       for (const pattern of patterns) {
-        const fsFiles = await (0, import_build_utils2.glob)(pattern, entrypointDirname);
+        const fsFiles = await (0, import_build_utils4.glob)(pattern, entrypointDirname);
         for (const [assetName, asset] of Object.entries(fsFiles)) {
           includedFiles[assetName] = asset;
         }
       }
     }
-    const modulePath = goModPath ? (0, import_path5.dirname)(goModPath) : void 0;
+    const modulePath = goModPath ? (0, import_path7.dirname)(goModPath) : void 0;
     const go = await createGo({
       modulePath,
       opts: {
@@ -17237,7 +17403,7 @@ Manually assigning 'GO111MODULE' is not recommended.
       },
       workPath
     });
-    const outDir = await (0, import_build_utils2.getWriteableDirectory)();
+    const outDir = await (0, import_build_utils4.getWriteableDirectory)();
     const buildOptions = {
       downloadPath,
       entrypoint,
@@ -17256,9 +17422,9 @@ Manually assigning 'GO111MODULE' is not recommended.
     } else {
       await buildHandlerWithGoMod(buildOptions);
     }
-    const runtime = await (0, import_build_utils2.getProvidedRuntime)();
-    const lambda = new import_build_utils2.Lambda({
-      files: { ...await (0, import_build_utils2.glob)("**", outDir), ...includedFiles },
+    const runtime = await (0, import_build_utils4.getProvidedRuntime)();
+    const lambda = new import_build_utils4.Lambda({
+      files: { ...await (0, import_build_utils4.glob)("**", outDir), ...includedFiles },
       handler: HANDLER_FILENAME,
       runtime,
       runtimeLanguage: "go",
@@ -17269,7 +17435,7 @@ Manually assigning 'GO111MODULE' is not recommended.
       output: lambda
     };
   } catch (error) {
-    (0, import_build_utils2.debug)(`Go Builder Error: ${error}`);
+    (0, import_build_utils4.debug)(`Go Builder Error: ${error}`);
     throw error;
   } finally {
     try {
@@ -17278,7 +17444,7 @@ Manually assigning 'GO111MODULE' is not recommended.
       if (error instanceof Error) {
         console.error(`Build cleanup failed: ${error.message}`);
       }
-      (0, import_build_utils2.debug)("Cleanup Error: " + error);
+      (0, import_build_utils4.debug)("Cleanup Error: " + error);
     }
   }
 }
@@ -17295,20 +17461,20 @@ async function buildHandlerWithGoMod({
   packageName,
   undo
 }) {
-  (0, import_build_utils2.debug)(
+  (0, import_build_utils4.debug)(
     `Building Go handler as package "${packageName}" (with${goModPath ? "" : "out"} go.mod)`
   );
   let goModDirname;
   if (goModPath !== void 0) {
-    goModDirname = (0, import_path5.dirname)(goModPath);
-    const backupFile = (0, import_path5.join)(goModDirname, `__vc_go.mod.bak`);
-    await (0, import_fs_extra2.copy)(goModPath, backupFile);
+    goModDirname = (0, import_path7.dirname)(goModPath);
+    const backupFile = (0, import_path7.join)(goModDirname, `__vc_go.mod.bak`);
+    await (0, import_fs_extra4.copy)(goModPath, backupFile);
     undo.fileActions.push({
       to: goModPath,
       from: backupFile
     });
-    const goSumPath = (0, import_path5.join)(goModDirname, "go.sum");
-    const isGoSumExists = await (0, import_fs_extra2.pathExists)(goSumPath);
+    const goSumPath = (0, import_path7.join)(goModDirname, "go.sum");
+    const isGoSumExists = await (0, import_fs_extra4.pathExists)(goSumPath);
     if (!isGoSumExists) {
       undo.fileActions.push({
         to: void 0,
@@ -17317,23 +17483,23 @@ async function buildHandlerWithGoMod({
       });
     }
   }
-  const entrypointArr = entrypoint.split(import_path5.posix.sep);
+  const entrypointArr = entrypoint.split(import_path7.posix.sep);
   let goPackageName = `${packageName}/${packageName}`;
   const goFuncName = `${packageName}.${handlerFunctionName}`;
-  const relPackagePath = goModDirname ? import_path5.posix.relative(goModDirname, entrypointDirname) : "";
+  const relPackagePath = goModDirname ? import_path7.posix.relative(goModDirname, entrypointDirname) : "";
   if (relPackagePath) {
-    goPackageName = import_path5.posix.join(packageName, relPackagePath);
+    goPackageName = import_path7.posix.join(packageName, relPackagePath);
   }
   let mainGoFile;
   if (goModPath && isGoModInRootDir) {
-    (0, import_build_utils2.debug)(`[mod-root] Write main file to ${downloadPath}`);
-    mainGoFile = (0, import_path5.join)(downloadPath, MAIN_GO_FILENAME);
+    (0, import_build_utils4.debug)(`[mod-root] Write main file to ${downloadPath}`);
+    mainGoFile = (0, import_path7.join)(downloadPath, MAIN_GO_FILENAME);
   } else if (goModDirname && !isGoModInRootDir) {
-    (0, import_build_utils2.debug)(`[mod-other] Write main file to ${goModDirname}`);
-    mainGoFile = (0, import_path5.join)(goModDirname, MAIN_GO_FILENAME);
+    (0, import_build_utils4.debug)(`[mod-other] Write main file to ${goModDirname}`);
+    mainGoFile = (0, import_path7.join)(goModDirname, MAIN_GO_FILENAME);
   } else {
-    (0, import_build_utils2.debug)(`[entrypoint] Write main file to ${entrypointDirname}`);
-    mainGoFile = (0, import_path5.join)(entrypointDirname, MAIN_GO_FILENAME);
+    (0, import_build_utils4.debug)(`[entrypoint] Write main file to ${entrypointDirname}`);
+    mainGoFile = (0, import_path7.join)(entrypointDirname, MAIN_GO_FILENAME);
   }
   await Promise.all([
     writeEntrypoint(mainGoFile, goPackageName, goFuncName),
@@ -17349,24 +17515,24 @@ async function buildHandlerWithGoMod({
     from: mainGoFile
   });
   try {
-    let finalDestination = (0, import_path5.join)(entrypointDirname, packageName, entrypoint);
+    let finalDestination = (0, import_path7.join)(entrypointDirname, packageName, entrypoint);
     if (entrypointArr.length > 1) {
-      finalDestination = (0, import_path5.join)(
+      finalDestination = (0, import_path7.join)(
         entrypointDirname,
         packageName,
         entrypointArr[entrypointArr.length - 1]
       );
     }
-    if (!goModPath || (0, import_path5.dirname)(entrypointAbsolute) === (0, import_path5.dirname)(goModPath)) {
-      (0, import_build_utils2.debug)(
+    if (!goModPath || (0, import_path7.dirname)(entrypointAbsolute) === (0, import_path7.dirname)(goModPath)) {
+      (0, import_build_utils4.debug)(
         `moving entrypoint "${entrypointAbsolute}" to "${finalDestination}"`
       );
-      await (0, import_fs_extra2.move)(entrypointAbsolute, finalDestination);
+      await (0, import_fs_extra4.move)(entrypointAbsolute, finalDestination);
       undo.fileActions.push({
         to: entrypointAbsolute,
         from: finalDestination
       });
-      undo.directoryCreation.push((0, import_path5.dirname)(finalDestination));
+      undo.directoryCreation.push((0, import_path7.dirname)(finalDestination));
     }
   } catch (err) {
     console.error("Failed to move entry to package folder");
@@ -17376,21 +17542,21 @@ async function buildHandlerWithGoMod({
   if (goModPath && isGoModInRootDir) {
     baseGoModPath = downloadPath;
   } else if (goModPath && !isGoModInRootDir) {
-    baseGoModPath = (0, import_path5.dirname)(goModPath);
+    baseGoModPath = (0, import_path7.dirname)(goModPath);
   } else {
     baseGoModPath = entrypointDirname;
   }
-  (0, import_build_utils2.debug)("Tidy `go.mod` file...");
+  (0, import_build_utils4.debug)("Tidy `go.mod` file...");
   try {
     await go.mod();
   } catch (err) {
     console.error("failed to `go mod tidy`");
     throw err;
   }
-  (0, import_build_utils2.debug)("Running `go build`...");
-  const destPath = (0, import_path5.join)(outDir, HANDLER_FILENAME);
+  (0, import_build_utils4.debug)("Running `go build`...");
+  const destPath = (0, import_path7.join)(outDir, HANDLER_FILENAME);
   try {
-    const src = [(0, import_path5.join)(baseGoModPath, MAIN_GO_FILENAME)];
+    const src = [(0, import_path7.join)(baseGoModPath, MAIN_GO_FILENAME)];
     await go.build(src, destPath);
   } catch (err) {
     console.error("failed to `go build`");
@@ -17405,31 +17571,31 @@ async function buildHandlerAsPackageMain({
   outDir,
   undo
 }) {
-  (0, import_build_utils2.debug)('Building Go handler as package "main" (legacy)');
+  (0, import_build_utils4.debug)('Building Go handler as package "main" (legacy)');
   await writeEntrypoint(
-    (0, import_path5.join)(entrypointDirname, MAIN_GO_FILENAME),
+    (0, import_path7.join)(entrypointDirname, MAIN_GO_FILENAME),
     "",
     handlerFunctionName
   );
   undo.fileActions.push({
     to: void 0,
     // delete
-    from: (0, import_path5.join)(entrypointDirname, MAIN_GO_FILENAME)
+    from: (0, import_path7.join)(entrypointDirname, MAIN_GO_FILENAME)
   });
-  (0, import_build_utils2.debug)("Running `go get`...");
+  (0, import_build_utils4.debug)("Running `go get`...");
   try {
     await go.get();
   } catch (err) {
     console.error("Failed to `go get`");
     throw err;
   }
-  (0, import_build_utils2.debug)("Running `go build`...");
-  const destPath = (0, import_path5.join)(outDir, HANDLER_FILENAME);
+  (0, import_build_utils4.debug)("Running `go build`...");
+  const destPath = (0, import_path7.join)(outDir, HANDLER_FILENAME);
   try {
     const src = [
-      (0, import_path5.join)(entrypointDirname, MAIN_GO_FILENAME),
+      (0, import_path7.join)(entrypointDirname, MAIN_GO_FILENAME),
       entrypointAbsolute
-    ].map((file) => (0, import_path5.normalize)(file));
+    ].map((file) => (0, import_path7.normalize)(file));
     await go.build(src, destPath);
   } catch (err) {
     console.error("failed to `go build`");
@@ -17437,10 +17603,10 @@ async function buildHandlerAsPackageMain({
   }
 }
 async function renameHandlerFunction(fsPath, from, to) {
-  let fileContents = await (0, import_fs_extra2.readFile)(fsPath, "utf8");
+  let fileContents = await (0, import_fs_extra4.readFile)(fsPath, "utf8");
   const fromRegex = new RegExp(String.raw` ${from}\b`, "g");
   fileContents = fileContents.replace(fromRegex, ` ${to}`);
-  await (0, import_fs_extra2.writeFile)(fsPath, fileContents);
+  await (0, import_fs_extra4.writeFile)(fsPath, fileContents);
 }
 function getNewHandlerFunctionName(originalFunctionName, entrypoint) {
   if (!originalFunctionName) {
@@ -17453,10 +17619,10 @@ function getNewHandlerFunctionName(originalFunctionName, entrypoint) {
       "Handler function renaming failed because entrypoint was empty."
     );
   }
-  (0, import_build_utils2.debug)(`Found exported function "${originalFunctionName}" in "${entrypoint}"`);
+  (0, import_build_utils4.debug)(`Found exported function "${originalFunctionName}" in "${entrypoint}"`);
   const pathSlug = entrypoint.replace(/(\s|\\|\/|\]|\[|-|\.)/g, "_");
   const newHandlerName = `${originalFunctionName}_${pathSlug}`;
-  (0, import_build_utils2.debug)(
+  (0, import_build_utils4.debug)(
     `Renaming handler function temporarily from "${originalFunctionName}" to "${newHandlerName}"`
   );
   return newHandlerName;
@@ -17468,36 +17634,36 @@ async function cleanupFileSystem({
 }) {
   for (const action of fileActions.reverse()) {
     if (action.to) {
-      await (0, import_fs_extra2.move)(action.from, action.to, { overwrite: true });
+      await (0, import_fs_extra4.move)(action.from, action.to, { overwrite: true });
     } else {
-      await (0, import_fs_extra2.remove)(action.from);
+      await (0, import_fs_extra4.remove)(action.from);
     }
   }
   for (const rename of functionRenames) {
     await renameHandlerFunction(rename.fsPath, rename.from, rename.to);
   }
   const undoDirectoryPromises = directoryCreation.map(async (directory) => {
-    const contents = await (0, import_fs_extra2.readdir)(directory);
+    const contents = await (0, import_fs_extra4.readdir)(directory);
     if (!contents.length) {
-      return (0, import_fs_extra2.rmdir)(directory);
+      return (0, import_fs_extra4.rmdir)(directory);
     }
     return void 0;
   });
   await Promise.all(undoDirectoryPromises);
 }
-async function findGoModPath(entrypointDir, workPath) {
+async function findGoModPath2(entrypointDir, workPath) {
   let goModPath = void 0;
   let isGoModInRootDir = false;
   let dir = entrypointDir;
   while (!isGoModInRootDir) {
     isGoModInRootDir = dir === workPath;
-    const goMod = (0, import_path5.join)(dir, "go.mod");
-    if (await (0, import_fs_extra2.pathExists)(goMod)) {
+    const goMod = (0, import_path7.join)(dir, "go.mod");
+    if (await (0, import_fs_extra4.pathExists)(goMod)) {
       goModPath = goMod;
-      (0, import_build_utils2.debug)(`Found ${goModPath}"`);
+      (0, import_build_utils4.debug)(`Found ${goModPath}"`);
       break;
     }
-    dir = (0, import_path5.dirname)(dir);
+    dir = (0, import_path7.dirname)(dir);
   }
   return {
     goModPath,
@@ -17511,22 +17677,22 @@ function isReadable2(v) {
   return v && v.readable === true;
 }
 async function copyEntrypoint(entrypoint, dest) {
-  const data = await (0, import_fs_extra2.readFile)(entrypoint, "utf8");
+  const data = await (0, import_fs_extra4.readFile)(entrypoint, "utf8");
   const patched = data.replace(/\bpackage\W+\S+\b/, "package main");
-  await (0, import_fs_extra2.writeFile)((0, import_path5.join)(dest, "entrypoint.go"), patched);
+  await (0, import_fs_extra4.writeFile)((0, import_path7.join)(dest, "entrypoint.go"), patched);
 }
 async function copyDevServer(functionName, dest) {
-  const data = await (0, import_fs_extra2.readFile)((0, import_path5.join)(__dirname, "../dev-server.go"), "utf8");
+  const data = await (0, import_fs_extra4.readFile)((0, import_path7.join)(__dirname, "../dev-server.go"), "utf8");
   const patched = data.replace("__HANDLER_FUNC_NAME", functionName);
-  await (0, import_fs_extra2.writeFile)((0, import_path5.join)(dest, "vercel-dev-server-main.go"), patched);
+  await (0, import_fs_extra4.writeFile)((0, import_path7.join)(dest, "vercel-dev-server-main.go"), patched);
 }
 async function writeEntrypoint(dest, goPackageName, goFuncName) {
-  const modMainGoContents = await (0, import_fs_extra2.readFile)(
-    (0, import_path5.join)(__dirname, "../main.go"),
+  const modMainGoContents = await (0, import_fs_extra4.readFile)(
+    (0, import_path7.join)(__dirname, "../main.go"),
     "utf8"
   );
   const mainModGoContents = modMainGoContents.replace("__VC_HANDLER_PACKAGE_NAME", goPackageName).replace("__VC_HANDLER_FUNC_NAME", goFuncName);
-  await (0, import_fs_extra2.writeFile)(dest, mainModGoContents, "utf-8");
+  await (0, import_fs_extra4.writeFile)(dest, mainModGoContents, "utf-8");
 }
 async function writeGoMod({
   destDir,
@@ -17535,13 +17701,13 @@ async function writeGoMod({
 }) {
   let contents = `module ${packageName}`;
   if (goModPath) {
-    const goModRelPath = (0, import_path5.relative)(destDir, (0, import_path5.dirname)(goModPath));
-    const goModContents = await (0, import_fs_extra2.readFile)(goModPath, "utf-8");
+    const goModRelPath = (0, import_path7.relative)(destDir, (0, import_path7.dirname)(goModPath));
+    const goModContents = await (0, import_fs_extra4.readFile)(goModPath, "utf-8");
     contents = goModContents.replace(/^module\s+.+$/m, contents).replace(
       /^(replace .+=>\s*)(.+)$/gm,
       (orig, replaceStmt, replacePath) => {
         if (replacePath.startsWith(".")) {
-          return replaceStmt + (0, import_path5.join)(goModRelPath, replacePath);
+          return replaceStmt + (0, import_path7.join)(goModRelPath, replacePath);
         }
         return orig;
       }
@@ -17549,7 +17715,7 @@ async function writeGoMod({
     const matches = goModContents.match(/module\s+(.+)/);
     const moduleName = matches ? matches[1] : null;
     if (moduleName) {
-      let relPath = (0, import_path5.normalize)(goModRelPath);
+      let relPath = (0, import_path7.normalize)(goModRelPath);
       if (!relPath.endsWith("/")) {
         relPath += "/";
       }
@@ -17569,25 +17735,25 @@ async function writeGoMod({
       }
     }
   }
-  const destGoModPath = (0, import_path5.join)(destDir, "go.mod");
-  (0, import_build_utils2.debug)(`Writing ${destGoModPath}`);
-  await (0, import_fs_extra2.writeFile)(destGoModPath, contents, "utf-8");
+  const destGoModPath = (0, import_path7.join)(destDir, "go.mod");
+  (0, import_build_utils4.debug)(`Writing ${destGoModPath}`);
+  await (0, import_fs_extra4.writeFile)(destGoModPath, contents, "utf-8");
 }
 async function findGoWorkFile(goWorkDir, workPath) {
-  while (!await (0, import_fs_extra2.pathExists)((0, import_path5.join)(goWorkDir, "go.work"))) {
+  while (!await (0, import_fs_extra4.pathExists)((0, import_path7.join)(goWorkDir, "go.work"))) {
     if (goWorkDir === workPath) {
       return;
     }
-    goWorkDir = (0, import_path5.dirname)(goWorkDir);
+    goWorkDir = (0, import_path7.dirname)(goWorkDir);
   }
-  return (0, import_path5.join)(goWorkDir, "go.work");
+  return (0, import_path7.join)(goWorkDir, "go.work");
 }
 async function writeGoWork(destDir, workPath, modulePath) {
   const workspaces = /* @__PURE__ */ new Set(["."]);
   const goWorkPath = await findGoWorkFile(modulePath || workPath, workPath);
   let goVersion;
   if (goWorkPath) {
-    const contents2 = await (0, import_fs_extra2.readFile)(goWorkPath, "utf-8");
+    const contents2 = await (0, import_fs_extra4.readFile)(goWorkPath, "utf-8");
     const goVersionMatch = contents2.match(/^go\s+(\d+\.\d+(\.\d+)?)/m);
     if (goVersionMatch) {
       goVersion = goVersionMatch[1];
@@ -17595,7 +17761,7 @@ async function writeGoWork(destDir, workPath, modulePath) {
     const addPath = (path8) => {
       if (path8) {
         if (path8.startsWith(".")) {
-          workspaces.add((0, import_path5.relative)(destDir, (0, import_path5.join)(workPath, path8)));
+          workspaces.add((0, import_path7.relative)(destDir, (0, import_path7.join)(workPath, path8)));
         } else {
           workspaces.add(path8);
         }
@@ -17618,10 +17784,10 @@ async function writeGoWork(destDir, workPath, modulePath) {
       match = singleRE.exec(contents2);
     }
   } else if (modulePath) {
-    workspaces.add((0, import_path5.relative)(destDir, modulePath));
-    const goModPath = (0, import_path5.join)(modulePath, "go.mod");
-    if (await (0, import_fs_extra2.pathExists)(goModPath)) {
-      const goModContents = await (0, import_fs_extra2.readFile)(goModPath, "utf-8");
+    workspaces.add((0, import_path7.relative)(destDir, modulePath));
+    const goModPath = (0, import_path7.join)(modulePath, "go.mod");
+    if (await (0, import_fs_extra4.pathExists)(goModPath)) {
+      const goModContents = await (0, import_fs_extra4.readFile)(goModPath, "utf-8");
       const goVersionMatch = goModContents.match(/^go\s+(\d+\.\d+(\.\d+)?)/m);
       if (goVersionMatch) {
         goVersion = goVersionMatch[1];
@@ -17638,24 +17804,36 @@ async function writeGoWork(destDir, workPath, modulePath) {
 ${Array.from(workspaces).map((w) => `  ${w}
 `).join("")})
 `;
-  await (0, import_fs_extra2.writeFile)((0, import_path5.join)(destDir, "go.work"), contents, "utf-8");
+  await (0, import_fs_extra4.writeFile)((0, import_path7.join)(destDir, "go.work"), contents, "utf-8");
 }
 async function startDevServer(opts) {
-  const { entrypoint, workPath, meta = {} } = opts;
-  const { devCacheDir = (0, import_path5.join)(workPath, ".vercel", "cache") } = meta;
-  const entrypointDir = (0, import_path5.dirname)(entrypoint);
+  const { entrypoint, workPath, config, meta = {} } = opts;
+  const { devCacheDir = (0, import_path7.join)(workPath, ".vercel", "cache") } = meta;
   let entrypointWithExt = entrypoint;
   if (!entrypoint.endsWith(".go")) {
     entrypointWithExt += ".go";
   }
-  const tmp = (0, import_path5.join)(devCacheDir, "go", Math.random().toString(32).substring(2));
-  const tmpPackage = (0, import_path5.join)(tmp, entrypointDir);
-  await (0, import_fs_extra2.mkdirp)(tmpPackage);
-  const { goModPath } = await findGoModPath(
-    (0, import_path5.join)(workPath, entrypointDir),
+  if (config?.framework === "go" || config?.framework === "services") {
+    const resolvedEntrypoint = await detectGoEntrypoint(
+      workPath,
+      entrypointWithExt
+    );
+    if (!resolvedEntrypoint) {
+      throw new Error(
+        `No Go entrypoint found. Expected one of: ${GO_CANDIDATE_ENTRYPOINTS.join(", ")}`
+      );
+    }
+    return startStandaloneDevServer(opts, resolvedEntrypoint);
+  }
+  const entrypointDir = (0, import_path7.dirname)(entrypointWithExt);
+  const tmp = (0, import_path7.join)(devCacheDir, "go", Math.random().toString(32).substring(2));
+  const tmpPackage = (0, import_path7.join)(tmp, entrypointDir);
+  await (0, import_fs_extra4.mkdirp)(tmpPackage);
+  const { goModPath } = await findGoModPath2(
+    (0, import_path7.join)(workPath, entrypointDir),
     workPath
   );
-  const modulePath = goModPath ? (0, import_path5.dirname)(goModPath) : void 0;
+  const modulePath = goModPath ? (0, import_path7.dirname)(goModPath) : void 0;
   const analyzed = await getAnalyzedEntrypoint({
     entrypoint: entrypointWithExt,
     modulePath,
@@ -17671,11 +17849,11 @@ async function startDevServer(opts) {
     }),
     writeGoWork(tmp, workPath, modulePath)
   ]);
-  const portFile = (0, import_path5.join)(
+  const portFile = (0, import_path7.join)(
     TMP,
     `vercel-dev-port-${Math.random().toString(32).substring(2)}`
   );
-  const env = (0, import_build_utils2.cloneEnv)(process.env, meta.env, {
+  const env = (0, import_build_utils4.cloneEnv)(process.env, meta.env, {
     VERCEL_DEV_PORT_FILE: portFile
   });
   const executable = `./vercel-dev-server-go${process.platform === "win32" ? ".exe" : ""}`;
@@ -17688,15 +17866,15 @@ async function startDevServer(opts) {
     workPath
   });
   await go.build("./...", executable);
-  (0, import_build_utils2.debug)(`SPAWNING ${executable} CWD=${tmp}`);
-  const child = (0, import_child_process.spawn)(executable, [], {
+  (0, import_build_utils4.debug)(`SPAWNING ${executable} CWD=${tmp}`);
+  const child = (0, import_child_process2.spawn)(executable, [], {
     cwd: tmp,
     env,
     stdio: ["ignore", "inherit", "inherit", "pipe"]
   });
   child.on("close", async () => {
     try {
-      await (0, import_async_retry.default)(() => (0, import_fs_extra2.remove)(tmp));
+      await (0, import_async_retry.default)(() => (0, import_fs_extra4.remove)(tmp));
     } catch (err) {
       console.error(`Could not delete tmp directory: ${tmp}: ${err}`);
     }
@@ -17741,8 +17919,8 @@ async function waitForPortFile_(opts) {
   while (!opts.canceled) {
     await new Promise((resolve) => setTimeout(resolve, 100));
     try {
-      const port = Number(await (0, import_fs_extra2.readFile)(opts.portFile, "ascii"));
-      (0, import_async_retry.default)(() => (0, import_fs_extra2.remove)(opts.portFile)).catch((err) => {
+      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) => {
         console.error(`Could not delete port file: ${opts.portFile}: ${err}`);
       });
       return { port };
@@ -17756,15 +17934,15 @@ async function waitForPortFile_(opts) {
 async function prepareCache({
   workPath
 }) {
-  const goCacheDir = (0, import_path5.join)(workPath, localCacheDir);
-  const stat = await (0, import_fs_extra2.lstat)(goCacheDir);
+  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_extra2.readlink)(goCacheDir);
-    (0, import_build_utils2.debug)(`Preparing cache by moving ${goGlobalCacheDir} -> ${goCacheDir}`);
-    await (0, import_fs_extra2.unlink)(goCacheDir);
-    await (0, import_fs_extra2.move)(goGlobalCacheDir, goCacheDir);
+    const goGlobalCacheDir = await (0, import_fs_extra4.readlink)(goCacheDir);
+    (0, import_build_utils4.debug)(`Preparing cache by moving ${goGlobalCacheDir} -> ${goCacheDir}`);
+    await (0, import_fs_extra4.unlink)(goCacheDir);
+    await (0, import_fs_extra4.move)(goGlobalCacheDir, goCacheDir);
   }
-  const cache2 = await (0, import_build_utils2.glob)(`${localCacheDir}/**`, workPath);
+  const cache2 = await (0, import_build_utils4.glob)(`${localCacheDir}/**`, workPath);
   return cache2;
 }
 // Annotate the CommonJS export names for ESM import in node: