@vercel/go 4.0.0 → 6.0.0

package/dist/index.js

@@ -2199,14 +2199,14 @@ var require_signal_exit = __commonJS({
         if (opts && opts.alwaysLast) {
           ev = "afterexit";
         }
-        var remove3 = function() {
+        var remove4 = function() {
           emitter.removeListener(ev, cb);
           if (emitter.listeners("exit").length === 0 && emitter.listeners("afterexit").length === 0) {
             unload();
           }
         };
         emitter.on(ev, cb);
-        return remove3;
+        return remove4;
       };
       unload = function unload2() {
         if (!loaded || !processOk(global.process)) {
@@ -4372,7 +4372,7 @@ var require_copy = __commonJS({
     "use strict";
     var fs3 = require_graceful_fs();
     var path = require("path");
-    var mkdirp3 = require_mkdirs2().mkdirs;
+    var mkdirp4 = require_mkdirs2().mkdirs;
     var pathExists5 = require_path_exists().pathExists;
     var utimes = require_utimes().utimesMillis;
     var notExist = Symbol("notExist");
@@ -4408,7 +4408,7 @@ var require_copy = __commonJS({
           return cb(err);
         if (dirExists)
           return startCopy(destStat, src, dest, opts, cb);
-        mkdirp3(destParent, (err2) => {
+        mkdirp4(destParent, (err2) => {
           if (err2)
             return cb(err2);
           return startCopy(destStat, src, dest, opts, cb);
@@ -4889,7 +4889,7 @@ var require_empty = __commonJS({
     var fs3 = require("fs");
     var path = require("path");
     var mkdir = require_mkdirs2();
-    var remove3 = require_remove();
+    var remove4 = require_remove();
     var emptyDir = u2(function emptyDir2(dir, callback) {
       callback = callback || function() {
       };
@@ -4902,7 +4902,7 @@ var require_empty = __commonJS({
           const item = items.pop();
           if (!item)
             return callback();
-          remove3.remove(item, (err2) => {
+          remove4.remove(item, (err2) => {
             if (err2)
               return callback(err2);
             deleteItem();
@@ -4919,7 +4919,7 @@ var require_empty = __commonJS({
       }
       items.forEach((item) => {
         item = path.join(dir, item);
-        remove3.removeSync(item);
+        remove4.removeSync(item);
       });
     }
     module2.exports = {
@@ -5574,8 +5574,8 @@ var require_move = __commonJS({
     var fs3 = require_graceful_fs();
     var path = require("path");
     var copy3 = require_copy2().copy;
-    var remove3 = require_remove().remove;
-    var mkdirp3 = require_mkdirs2().mkdirp;
+    var remove4 = require_remove().remove;
+    var mkdirp4 = require_mkdirs2().mkdirp;
     var pathExists5 = require_path_exists().pathExists;
     function move2(src, dest, opts, cb) {
       if (typeof opts === "function") {
@@ -5593,7 +5593,7 @@ var require_move = __commonJS({
         if (st2.isDirectory() && isSrcSubdir(src, dest)) {
           return cb(new Error(`Cannot move '${src}' to a subdirectory of itself, '${dest}'.`));
         }
-        mkdirp3(path.dirname(dest), (err2) => {
+        mkdirp4(path.dirname(dest), (err2) => {
           if (err2)
             return cb(err2);
           return doRename(src, dest, overwrite, cb);
@@ -5602,7 +5602,7 @@ var require_move = __commonJS({
     }
     function doRename(src, dest, overwrite, cb) {
       if (overwrite) {
-        return remove3(dest, (err) => {
+        return remove4(dest, (err) => {
           if (err)
             return cb(err);
           return rename(src, dest, overwrite, cb);
@@ -5633,7 +5633,7 @@ var require_move = __commonJS({
       copy3(src, dest, opts, (err) => {
         if (err)
           return cb(err);
-        return remove3(src, cb);
+        return remove4(src, cb);
       });
     }
     function isSrcSubdir(src, dest) {
@@ -10967,9 +10967,9 @@ var require_dev_proxy = __commonJS({
       resolveServiceRoutePrefix: () => resolveServiceRoutePrefix,
       rewriteRequestUrl: () => rewriteRequestUrl,
       sanitizeHeaders: () => sanitizeHeaders,
-      startDevProxy: () => startDevProxy,
+      startDevProxy: () => startDevProxy2,
       stripServiceRoutePrefix: () => stripServiceRoutePrefix,
-      waitForPort: () => waitForPort2
+      waitForPort: () => waitForPort
     });
     module2.exports = __toCommonJS2(dev_proxy_exports);
     var import_node_http = require("http");
@@ -11060,7 +11060,7 @@ var require_dev_proxy = __commonJS({
         });
       });
     }
-    function isPortReachable2(port) {
+    function isPortReachable(port) {
       return new Promise((resolve) => {
         const socket = (0, import_node_net.createConnection)({ port, host: LOCALHOST });
         const done = (reachable) => {
@@ -11074,10 +11074,10 @@ var require_dev_proxy = __commonJS({
         socket.once("error", () => done(false));
       });
     }
-    function sleep2(ms2) {
+    function sleep(ms2) {
       return new Promise((resolve) => setTimeout(resolve, ms2));
     }
-    async function waitForPort2(port, child, timeout, label = "Dev server") {
+    async function waitForPort(port, child, timeout, label = "Dev server") {
       let exited;
       let spawnError;
       const onExit = (code, signal) => {
@@ -11098,9 +11098,9 @@ var require_dev_proxy = __commonJS({
               `${label} exited before it started listening (code: ${exited.code}, signal: ${exited.signal})`
             );
           }
-          if (await isPortReachable2(port))
+          if (await isPortReachable(port))
             return;
-          await sleep2(READINESS_POLL_INTERVAL);
+          await sleep(READINESS_POLL_INTERVAL);
         }
         throw new Error(`${label} did not start listening within ${timeout}ms`);
       } finally {
@@ -11176,7 +11176,7 @@ var require_dev_proxy = __commonJS({
       });
       return server;
     }
-    async function startDevProxy(options) {
+    async function startDevProxy2(options) {
       const {
         spawnServer,
         env = process.env,
@@ -11198,7 +11198,7 @@ var require_dev_proxy = __commonJS({
         }
       };
       try {
-        await waitForPort2(internalPort, child, readinessTimeout, label);
+        await waitForPort(internalPort, child, readinessTimeout, label);
         server = createDevProxyServer({
           targetPort: internalPort,
           routePrefix: resolveServiceRoutePrefix(env)
@@ -14579,6 +14579,7 @@ var localCacheDir = (0, import_path4.join)(".vercel", "cache", "golang");
 var GO_FLAGS = process.platform === "win32" ? [] : ["-ldflags", "-s -w"];
 var GO_MIN_MAJOR_VERSION = 1;
 var GO_MIN_MINOR_VERSION = 13;
+var GO_INSTALL_MARKER = ".vercel-go-install-complete";
 function getGoUrl(version2) {
   const { arch, platform } = process;
   const ext = platform === "win32" ? "zip" : "tar.gz";
@@ -14753,27 +14754,75 @@ var GoWrapper = class {
   getEnv() {
     return this.env;
   }
-  build(src, dest, { vendorMode = false } = {}) {
-    (0, import_build_utils.debug)(`Building optimized 'go' binary ${src} -> ${dest}`);
+  build(src, dest, { vendorMode = false, release = true } = {}) {
+    (0, import_build_utils.debug)(
+      `Building ${release ? "optimized" : "debug"} 'go' binary ${src} -> ${dest}`
+    );
     const sources = Array.isArray(src) ? src : [src];
     const envGoBuildFlags = (this.env || this.opts.env).GO_BUILD_FLAGS;
-    const flags = envGoBuildFlags ? (0, import_string_argv.default)(envGoBuildFlags) : [...GO_FLAGS];
+    const defaultFlags = release ? GO_FLAGS : [];
+    const flags = envGoBuildFlags ? (0, import_string_argv.default)(envGoBuildFlags) : [...defaultFlags];
     if (vendorMode && !envGoBuildFlags) {
       flags.push("-mod=vendor");
     }
     return this.execute("build", ...flags, "-o", dest, ...sources);
   }
 };
+function newestSupportedGoVersion() {
+  return Array.from(versionMap.values())[0];
+}
+function compareGoVersions(left, right) {
+  const leftParts = left.split(".").map((part) => parseInt(part, 10));
+  const rightParts = right.split(".").map((part) => parseInt(part, 10));
+  for (let index = 0; index < Math.max(leftParts.length, rightParts.length); index++) {
+    const difference = (leftParts[index] ?? 0) - (rightParts[index] ?? 0);
+    if (difference !== 0) {
+      return difference;
+    }
+  }
+  return 0;
+}
+function selectGoVersion(preferred, { preferNewestToolchain = false } = {}) {
+  if (preferred?.toolchain) {
+    return preferred.toolchain;
+  }
+  if (preferred && !preferNewestToolchain) {
+    return preferred.go;
+  }
+  const newestSupported = newestSupportedGoVersion();
+  if (preferred && compareGoVersions(preferred.go, newestSupported) > 0) {
+    return preferred.go;
+  }
+  return newestSupported;
+}
+var MIN_DARWIN_RUNNABLE_GO = { major: 1, minor: 23 };
+function isBelowMinDarwinRunnable(version2) {
+  const [major, minor] = version2.split(".").map((part) => parseInt(part, 10));
+  if (!Number.isFinite(major) || !Number.isFinite(minor))
+    return false;
+  if (major !== MIN_DARWIN_RUNNABLE_GO.major) {
+    return major < MIN_DARWIN_RUNNABLE_GO.major;
+  }
+  return minor < MIN_DARWIN_RUNNABLE_GO.minor;
+}
 async function createGo({
   modulePath,
   opts = {},
-  workPath
+  workPath,
+  preferNewestToolchain = false
 }) {
   let goPreferredVersion;
   if (modulePath) {
     goPreferredVersion = await parseGoModVersionFromModule(modulePath);
   }
-  const goSelectedVersion = goPreferredVersion ? goPreferredVersion.toolchain || goPreferredVersion.go : Array.from(versionMap.values())[0];
+  const goSelectedVersion = selectGoVersion(goPreferredVersion, {
+    preferNewestToolchain
+  });
+  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.`
+    );
+  }
   const env = opts.env ? (0, import_build_utils.cloneEnv)(opts.env) : (0, import_build_utils.cloneEnv)(process.env);
   const { PATH } = env;
   const { platform } = process;
@@ -14837,9 +14886,17 @@ async function createGo({
   for (const [label, goDir] of Object.entries(goDirs)) {
     try {
       const goBinDir = goDir && (0, import_path4.join)(goDir, "bin");
-      if (goBinDir && !await (0, import_fs_extra.pathExists)(goBinDir)) {
-        (0, import_build_utils.debug)(`Go not found in ${label}`);
-        continue;
+      if (goBinDir) {
+        if (!await (0, import_fs_extra.pathExists)(goBinDir)) {
+          (0, import_build_utils.debug)(`Go not found in ${label}`);
+          continue;
+        }
+        if (!await (0, import_fs_extra.pathExists)((0, import_path4.join)(goDir, GO_INSTALL_MARKER))) {
+          (0, import_build_utils.debug)(
+            `Go install in ${label} is incomplete, ignoring this installation`
+          );
+          continue;
+        }
       }
       env.GOROOT = goDir || void 0;
       env.PATH = goBinDir || PATH;
@@ -14876,40 +14933,56 @@ async function download({ dest, version: version2 }) {
   if (!res.ok) {
     throw new Error(`Failed to download: ${url} (${res.status})`);
   }
-  (0, import_build_utils.debug)(`Installing go ${version2} to ${dest}`);
-  await (0, import_fs_extra.remove)(dest);
-  await (0, import_fs_extra.mkdirp)(dest);
-  if (/\.zip$/.test(filename)) {
-    const zipFile = (0, import_path4.join)((0, import_os.tmpdir)(), filename);
-    try {
-      await streamPipeline(res.body, (0, import_fs_extra.createWriteStream)(zipFile));
-      const zip = await import_yauzl_promise.default.open(zipFile);
-      let entry = await zip.readEntry();
-      while (entry) {
-        const fileName = entry.fileName.split("/").slice(1).join("/");
-        if (fileName) {
-          const destPath = (0, import_path4.join)(dest, fileName);
-          if (/\/$/.test(fileName)) {
-            await (0, import_fs_extra.mkdirp)(destPath);
-          } else {
-            const [entryStream] = await Promise.all([
-              entry.openReadStream(),
-              (0, import_fs_extra.mkdirp)((0, import_path4.dirname)(destPath))
-            ]);
-            const out = (0, import_fs_extra.createWriteStream)(destPath);
-            await streamPipeline(entryStream, out);
+  const tmpSuffix = `${process.pid}-${Math.random().toString(36).slice(2)}`;
+  const tmpDest = `${dest}.tmp-${tmpSuffix}`;
+  (0, import_build_utils.debug)(`Installing go ${version2} to ${dest} (via ${tmpDest})`);
+  await (0, import_fs_extra.mkdirp)(tmpDest);
+  try {
+    if (/\.zip$/.test(filename)) {
+      const zipFile = (0, import_path4.join)((0, import_os.tmpdir)(), `${tmpSuffix}-${filename}`);
+      try {
+        await streamPipeline(res.body, (0, import_fs_extra.createWriteStream)(zipFile));
+        const zip = await import_yauzl_promise.default.open(zipFile);
+        let entry = await zip.readEntry();
+        while (entry) {
+          const fileName = entry.fileName.split("/").slice(1).join("/");
+          if (fileName) {
+            const destPath = (0, import_path4.join)(tmpDest, fileName);
+            if (/\/$/.test(fileName)) {
+              await (0, import_fs_extra.mkdirp)(destPath);
+            } else {
+              const [entryStream] = await Promise.all([
+                entry.openReadStream(),
+                (0, import_fs_extra.mkdirp)((0, import_path4.dirname)(destPath))
+              ]);
+              const out = (0, import_fs_extra.createWriteStream)(destPath);
+              await streamPipeline(entryStream, out);
+            }
           }
+          entry = await zip.readEntry();
         }
-        entry = await zip.readEntry();
+      } finally {
+        await (0, import_fs_extra.remove)(zipFile);
       }
-    } finally {
-      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);
+      });
     }
-    return;
+    await import_fs5.default.promises.writeFile((0, import_path4.join)(tmpDest, GO_INSTALL_MARKER), version2);
+    if (!await (0, import_fs_extra.pathExists)((0, import_path4.join)(dest, GO_INSTALL_MARKER))) {
+      await (0, import_fs_extra.remove)(dest);
+    }
+    try {
+      await import_fs5.default.promises.rename(tmpDest, dest);
+    } catch (err) {
+      if (!await (0, import_fs_extra.pathExists)((0, import_path4.join)(dest, GO_INSTALL_MARKER))) {
+        throw err;
+      }
+    }
+  } finally {
+    await (0, import_fs_extra.remove)(tmpDest);
   }
-  await new Promise((resolve, reject) => {
-    res.body.on("error", reject).pipe(lo({ cwd: dest, strip: 1 })).on("error", reject).on("finish", resolve);
-  });
 }
 var goVersionRegExp = /(\d+)\.(\d+)(?:\.(\d+))?/;
 function parseGoVersionString(goVersionOutput) {
@@ -15088,7 +15161,6 @@ var detectEntrypoint = async ({ workPath }) => {
 
 // src/standalone-server.ts
 var import_child_process = require("child_process");
-var import_net = require("net");
 var import_path6 = require("path");
 var import_fs_extra3 = __toESM(require_lib2());
 var import_build_utils4 = require("@vercel/build-utils");
@@ -15333,19 +15405,29 @@ async function createStandaloneServerLambda({
   });
   return lambda;
 }
-var DEV_SERVER_STARTUP_TIMEOUT = 5 * 6e4;
 var PERSISTENT_SERVERS = /* @__PURE__ */ new Map();
 var PENDING_STARTS = /* @__PURE__ */ new Map();
 var cleanupHandlersInstalled = false;
-function killStandaloneDevServer(pid) {
+function killStandaloneDevServerProcessTree(child) {
+  if (!child.pid)
+    return;
   try {
     if (process.platform === "win32") {
-      process.kill(pid, "SIGTERM");
+      child.kill("SIGTERM");
     } else {
-      process.kill(-pid, "SIGTERM");
+      process.kill(-child.pid, "SIGTERM");
     }
   } catch (err) {
-    (0, import_build_utils4.debug)(`Error killing standalone Go dev server ${pid}: ${err}`);
+    if (err.code !== "ESRCH") {
+      (0, import_build_utils4.debug)(`Error killing standalone Go dev server ${child.pid}: ${err}`);
+    }
+  }
+}
+async function closeStandaloneDevServer(handle) {
+  try {
+    await handle.close();
+  } finally {
+    killStandaloneDevServerProcessTree(handle.child);
   }
 }
 function installGlobalCleanupHandlers() {
@@ -15353,162 +15435,151 @@ function installGlobalCleanupHandlers() {
     return;
   cleanupHandlersInstalled = true;
   const killAll = () => {
-    for (const [key, info] of PERSISTENT_SERVERS.entries()) {
-      killStandaloneDevServer(info.pid);
+    for (const [key, server] of PERSISTENT_SERVERS.entries()) {
       PERSISTENT_SERVERS.delete(key);
+      killStandaloneDevServerProcessTree(server.handle.child);
     }
   };
-  process.on("SIGINT", () => {
-    killAll();
-  });
-  process.on("SIGTERM", () => {
-    killAll();
-  });
-  process.on("exit", () => {
-    killAll();
-  });
+  process.on("SIGINT", killAll);
+  process.on("SIGTERM", killAll);
+  process.on("exit", killAll);
 }
-function isPortReachable(port) {
-  return new Promise((resolve) => {
-    const socket = (0, import_net.createConnection)({ port, host: "127.0.0.1" });
-    const done = (result) => {
-      socket.removeAllListeners();
-      socket.destroy();
-      resolve(result);
-    };
-    socket.setTimeout(1e3);
-    socket.once("connect", () => done(true));
-    socket.once("timeout", () => done(false));
-    socket.once("error", () => done(false));
-  });
-}
-function sleep(ms2) {
-  return new Promise((resolve) => setTimeout(resolve, ms2));
-}
-async function waitForPort(port, child, timeout) {
-  let exited = null;
-  let spawnError = null;
-  const onExit = (code, signal) => {
-    exited = { code, signal };
-  };
-  const onError = (err) => {
-    spawnError = err;
-  };
-  child.once("exit", onExit);
-  child.once("error", onError);
-  try {
-    const start = Date.now();
-    while (Date.now() - start < timeout) {
-      if (spawnError) {
-        throw spawnError;
-      }
-      if (exited) {
-        const { code, signal } = exited;
-        throw new Error(
-          `Standalone Go dev server exited before startup completed (code: ${code}, signal: ${signal})`
-        );
-      }
-      if (await isPortReachable(port)) {
-        return;
+function toDevServerResult(serverKey, handle) {
+  return {
+    port: handle.port,
+    pid: handle.pid,
+    persistent: true,
+    shutdown: async () => {
+      if (PERSISTENT_SERVERS.get(serverKey)?.handle === handle) {
+        PERSISTENT_SERVERS.delete(serverKey);
       }
-      await sleep(100);
+      await closeStandaloneDevServer(handle);
     }
-    throw new Error(
-      `Standalone Go dev server did not start within ${timeout}ms`
-    );
-  } finally {
-    child.removeListener("exit", onExit);
-    child.removeListener("error", onError);
-  }
+  };
 }
 async function startStandaloneDevServer(opts, resolvedEntrypoint) {
   const { workPath, meta = {} } = opts;
+  const { devCacheDir = (0, import_path6.join)(workPath, ".vercel", "cache") } = meta;
   const serverKey = `${workPath}::${resolvedEntrypoint}`;
   const existing = PERSISTENT_SERVERS.get(serverKey);
   if (existing) {
-    return {
-      port: existing.port,
-      pid: existing.pid,
-      shutdown: async () => {
-      }
-    };
+    return toDevServerResult(serverKey, existing.handle);
   }
   const pending = PENDING_STARTS.get(serverKey);
   if (pending) {
-    const { port, pid } = await pending;
-    return { port, pid, shutdown: async () => {
-    } };
+    await pending;
+    return startStandaloneDevServer(opts, resolvedEntrypoint);
   }
   const startPromise = (async () => {
-    const port = typeof meta.port === "number" ? meta.port : Math.floor(Math.random() * (65535 - 49152) + 49152);
-    const env = (0, import_build_utils4.cloneEnv)(process.env, meta.env, {
-      PORT: String(port)
-    });
+    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 go = await createGo({
       modulePath,
       opts: { cwd: workPath, env },
-      workPath
+      workPath,
+      // The binary has to run on this machine, so don't downgrade.
+      preferNewestToolchain: true
     });
-    const runTarget = resolvedEntrypoint === "main.go" ? "." : "./" + (0, import_path6.dirname)(resolvedEntrypoint);
-    const devWrapper = (0, import_path6.join)(__dirname, "../bootstrap/vc-init-dev.go");
-    const devUtils = (0, import_path6.join)(__dirname, "../bootstrap/utils.go");
-    (0, import_build_utils4.debug)(
-      `Starting standalone Go dev server wrapper: go run ${devWrapper} (target ${runTarget}, port ${port})`
+    const buildTarget = resolvedEntrypoint === "main.go" ? "." : "./" + (0, import_path6.dirname)(resolvedEntrypoint);
+    const isVendored = await (0, import_fs_extra3.pathExists)(
+      (0, import_path6.join)(workPath, "vendor", "modules.txt")
     );
-    const child = (0, import_child_process.spawn)("go", ["run", "-tags", "vcdev", devWrapper, devUtils], {
-      cwd: workPath,
-      env: {
-        ...go.getEnv(),
-        __VC_GO_DEV_RUN_TARGET: runTarget
-      },
-      stdio: ["ignore", "pipe", "pipe"],
-      detached: process.platform !== "win32"
-    });
-    child.stdout?.on("data", (data) => {
-      const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
-      if (opts.onStdout) {
-        opts.onStdout(chunk);
-      } else {
-        process.stdout.write(chunk.toString());
-      }
-    });
-    child.stderr?.on("data", (data) => {
-      const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
-      if (opts.onStderr) {
-        opts.onStderr(chunk);
-      } else {
-        process.stderr.write(chunk.toString());
+    if (isVendored) {
+      (0, import_build_utils4.debug)("Detected vendor directory, using -mod=vendor for build");
+    }
+    const outDir = (0, import_path6.join)(
+      devCacheDir,
+      "go-standalone",
+      Math.random().toString(32).substring(2)
+    );
+    await (0, import_fs_extra3.mkdirp)(outDir);
+    const cleanupOutDir = async () => {
+      try {
+        await (0, import_fs_extra3.remove)(outDir);
+      } catch (err) {
+        (0, import_build_utils4.debug)(`Could not delete dev server directory ${outDir}: ${err}`);
       }
-    });
-    const pid = child.pid;
+    };
+    const executablePath = (0, import_path6.join)(
+      outDir,
+      `dev-server${process.platform === "win32" ? ".exe" : ""}`
+    );
+    (0, import_build_utils4.debug)(
+      `Building standalone Go dev server: go build ${buildTarget} -> ${executablePath}`
+    );
     try {
-      await waitForPort(port, child, DEV_SERVER_STARTUP_TIMEOUT);
+      await go.build(buildTarget, executablePath, {
+        vendorMode: isVendored,
+        release: false
+      });
     } catch (err) {
-      if (pid) {
-        killStandaloneDevServer(pid);
-      }
+      console.error(`Failed to build standalone Go server: ${buildTarget}`);
+      await cleanupOutDir();
       throw err;
     }
-    if (!pid) {
-      throw new Error("Standalone Go dev server started without a PID");
-    }
-    PERSISTENT_SERVERS.set(serverKey, { port, pid, child });
-    child.once("exit", () => {
-      PERSISTENT_SERVERS.delete(serverKey);
+    (0, import_build_utils4.debug)(`Starting standalone Go dev server: ${executablePath}`);
+    let spawnedChild;
+    const handle = await (0, import_ipc_proxy.startDevProxy)({
+      port: typeof meta.port === "number" ? meta.port : void 0,
+      env,
+      label: "Standalone Go dev server",
+      // Spawning the binary avoids a `go run` wrapper. On Unix, detaching also
+      // makes it a process-group leader so shutdown can include its helpers.
+      spawnServer: (internalPort) => {
+        const child = (0, import_child_process.spawn)(executablePath, [], {
+          cwd: workPath,
+          env: (0, import_build_utils4.cloneEnv)(go.getEnv(), { PORT: String(internalPort) }),
+          stdio: ["ignore", "pipe", "pipe"],
+          detached: process.platform !== "win32"
+        });
+        spawnedChild = child;
+        const forward = (stream, onData, fallback) => {
+          stream?.on("data", (data) => {
+            const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
+            if (onData) {
+              onData(chunk);
+            } else {
+              fallback.write(
+                new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength)
+              );
+            }
+          });
+        };
+        forward(child.stdout, opts.onStdout, process.stdout);
+        forward(child.stderr, opts.onStderr, process.stderr);
+        return child;
+      }
+    }).catch(async (err) => {
+      if (spawnedChild) {
+        killStandaloneDevServerProcessTree(spawnedChild);
+      }
+      await cleanupOutDir();
+      throw err;
+    });
+    const server = { handle };
+    PERSISTENT_SERVERS.set(serverKey, server);
+    handle.child.once("exit", () => {
+      if (PERSISTENT_SERVERS.get(serverKey)?.handle === handle) {
+        PERSISTENT_SERVERS.delete(serverKey);
+      }
+      closeStandaloneDevServer(handle).catch((err) => {
+        (0, import_build_utils4.debug)(`Error closing standalone Go dev proxy: ${err}`);
+      });
+      void cleanupOutDir();
     });
     installGlobalCleanupHandlers();
-    return { port, pid };
+    return server;
   })();
   PENDING_STARTS.set(serverKey, startPromise);
   try {
-    const { port, pid } = await startPromise;
-    return { port, pid, shutdown: async () => {
-    } };
+    const server = await startPromise;
+    return toDevServerResult(serverKey, server.handle);
   } finally {
-    PENDING_STARTS.delete(serverKey);
+    if (PENDING_STARTS.get(serverKey) === startPromise) {
+      PENDING_STARTS.delete(serverKey);
+    }
   }
 }
 
@@ -16167,9 +16238,11 @@ async function startDevServer(opts) {
       cwd: tmp,
       env
     },
-    workPath
+    workPath,
+    // The binary has to run on this machine, so don't downgrade.
+    preferNewestToolchain: true
   });
-  await go.build("./...", executable);
+  await go.build("./...", executable, { release: false });
   (0, import_build_utils5.debug)(`SPAWNING ${executable} CWD=${tmp}`);
   const child = (0, import_child_process2.spawn)(executable, [], {
     cwd: tmp,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/go",
-  "version": "4.0.0",
+  "version": "6.0.0",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/go",
@@ -12,12 +12,11 @@
   "files": [
     "dist",
     "*.go",
-    "bin",
-    "bootstrap"
+    "bin"
   ],
   "dependencies": {},
   "peerDependencies": {
-    "@vercel/build-utils": "14.3.0"
+    "@vercel/build-utils": "14.5.0"
   },
   "devDependencies": {
     "@tootallnate/once": "1.1.2",
@@ -36,7 +35,7 @@
     "vitest": "4.1.10",
     "xdg-app-paths": "5.1.0",
     "yauzl-promise": "2.1.3",
-    "@vercel/build-utils": "14.3.0",
+    "@vercel/build-utils": "14.5.0",
     "@vercel-internals/ipc-proxy": "1.0.0"
   },
   "scripts": {

package/bootstrap/utils.go

@@ -1,140 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"net"
-	"os"
-	"strings"
-	"time"
-)
-
-func findFreePort() (int, error) {
-	listener, err := net.Listen("tcp", "127.0.0.1:0")
-	if err != nil {
-		return 0, err
-	}
-	port := listener.Addr().(*net.TCPAddr).Port
-	listener.Close()
-	return port, nil
-}
-
-func waitForServer(port int, timeout time.Duration) error {
-	const (
-		dialTimeout  = 200 * time.Millisecond
-		pollInterval = 50 * time.Millisecond
-	)
-
-	addr := fmt.Sprintf("127.0.0.1:%d", port)
-	deadline := time.Now().Add(timeout)
-	var lastErr error
-
-	for time.Now().Before(deadline) {
-		remaining := time.Until(deadline)
-		if remaining <= 0 {
-			break
-		}
-
-		attemptTimeout := dialTimeout
-		if remaining < attemptTimeout {
-			attemptTimeout = remaining
-		}
-
-		conn, err := net.DialTimeout("tcp", addr, attemptTimeout)
-		if err == nil {
-			conn.Close()
-			return nil
-		}
-
-		lastErr = err
-		time.Sleep(pollInterval)
-	}
-
-	if lastErr != nil {
-		return fmt.Errorf(
-			"server did not start listening on %s within %v: %w",
-			addr,
-			timeout,
-			lastErr,
-		)
-	}
-
-	return fmt.Errorf("server did not start listening on %s within %v", addr, timeout)
-}
-
-func normalizeServiceRoutePrefix(rawPrefix string) string {
-	if rawPrefix == "" {
-		return ""
-	}
-
-	prefix := strings.TrimSpace(rawPrefix)
-	if prefix == "" {
-		return ""
-	}
-
-	if !strings.HasPrefix(prefix, "/") {
-		prefix = "/" + prefix
-	}
-
-	if prefix != "/" {
-		prefix = strings.TrimRight(prefix, "/")
-		if prefix == "" {
-			prefix = "/"
-		}
-	}
-
-	if prefix == "/" {
-		return ""
-	}
-
-	return prefix
-}
-
-func serviceRoutePrefixStripEnabled() bool {
-	raw := strings.TrimSpace(os.Getenv("VERCEL_SERVICE_ROUTE_PREFIX_STRIP"))
-	if raw == "" {
-		return false
-	}
-
-	normalized := strings.ToLower(raw)
-	return normalized == "1" || normalized == "true"
-}
-
-func resolveServiceRoutePrefix() string {
-	if !serviceRoutePrefixStripEnabled() {
-		return ""
-	}
-
-	return normalizeServiceRoutePrefix(os.Getenv("VERCEL_SERVICE_ROUTE_PREFIX"))
-}
-
-func stripServiceRoutePrefix(pathValue string, prefix string) string {
-	if pathValue == "*" {
-		return pathValue
-	}
-
-	normalizedPath := pathValue
-	if normalizedPath == "" {
-		normalizedPath = "/"
-	} else if !strings.HasPrefix(normalizedPath, "/") {
-		normalizedPath = "/" + normalizedPath
-	}
-
-	if prefix == "" {
-		return normalizedPath
-	}
-
-	if normalizedPath == prefix {
-		return "/"
-	}
-
-	prefixWithSlash := prefix + "/"
-	if strings.HasPrefix(normalizedPath, prefixWithSlash) {
-		stripped := normalizedPath[len(prefix):]
-		if stripped == "" {
-			return "/"
-		}
-		return stripped
-	}
-
-	return normalizedPath
-}

package/bootstrap/vc-init-dev.go

@@ -1,147 +0,0 @@
-//go:build vcdev
-// +build vcdev
-
-// vc-init-dev.go - Dev wrapper for standalone Go servers on Vercel
-//
-// This wrapper is used by `vercel dev` for standalone Go mode. It:
-// 1. Starts the user's server (`go run <target>`) on an internal port
-// 2. Proxies requests from the external dev port to the internal server
-// 3. Optionally strips generated services route prefixes before forwarding
-
-package main
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"net/http/httputil"
-	"net/url"
-	"os"
-	"os/exec"
-	"os/signal"
-	"strconv"
-	"strings"
-	"sync"
-	"syscall"
-	"time"
-)
-
-func mustEnv(name string) string {
-	value := strings.TrimSpace(os.Getenv(name))
-	if value == "" {
-		fmt.Fprintf(os.Stderr, "%s is not set\n", name)
-		os.Exit(1)
-	}
-	return value
-}
-
-func withEnvOverride(env []string, key, value string) []string {
-	prefix := key + "="
-	filtered := make([]string, 0, len(env)+1)
-	for _, item := range env {
-		if !strings.HasPrefix(item, prefix) {
-			filtered = append(filtered, item)
-		}
-	}
-	filtered = append(filtered, prefix+value)
-	return filtered
-}
-
-func main() {
-	listenPortRaw := mustEnv("PORT")
-	listenPort, err := strconv.Atoi(listenPortRaw)
-	if err != nil || listenPort <= 0 {
-		fmt.Fprintf(os.Stderr, "Invalid PORT value: %q\n", listenPortRaw)
-		os.Exit(1)
-	}
-
-	runTarget := mustEnv("__VC_GO_DEV_RUN_TARGET")
-	serviceRoutePrefix := resolveServiceRoutePrefix()
-
-	userPort, err := findFreePort()
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Failed to find free port: %v\n", err)
-		os.Exit(1)
-	}
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	cmd := exec.CommandContext(ctx, "go", "run", runTarget)
-	cmd.Env = withEnvOverride(os.Environ(), "PORT", strconv.Itoa(userPort))
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-
-	if err := cmd.Start(); err != nil {
-		fmt.Fprintf(os.Stderr, "Failed to start Go dev server: %v\n", err)
-		os.Exit(1)
-	}
-
-	if err := waitForServer(userPort, 30*time.Second); err != nil {
-		fmt.Fprintf(os.Stderr, "Go dev server failed to start: %v\n", err)
-		_ = cmd.Process.Kill()
-		os.Exit(1)
-	}
-
-	targetURL, _ := url.Parse(fmt.Sprintf("http://127.0.0.1:%d", userPort))
-	proxy := httputil.NewSingleHostReverseProxy(targetURL)
-	originalDirector := proxy.Director
-	proxy.Director = func(req *http.Request) {
-		originalDirector(req)
-		if host := req.Header.Get("X-Forwarded-Host"); host != "" {
-			req.Host = host
-		}
-	}
-
-	server := &http.Server{
-		Addr: fmt.Sprintf("127.0.0.1:%d", listenPort),
-		Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			if r.URL.Path == "/_vercel/ping" {
-				w.WriteHeader(http.StatusOK)
-				w.Write([]byte("OK"))
-				return
-			}
-
-			if r.URL != nil {
-				originalPath := r.URL.Path
-				r.URL.Path = stripServiceRoutePrefix(r.URL.Path, serviceRoutePrefix)
-				if r.URL.Path != originalPath {
-					r.URL.RawPath = ""
-				}
-			}
-
-			proxy.ServeHTTP(w, r)
-		}),
-	}
-
-	var closeOnce sync.Once
-	stop := func() {
-		closeOnce.Do(func() {
-			cancel()
-			_ = server.Close()
-			if cmd.Process != nil {
-				_ = cmd.Process.Kill()
-			}
-		})
-	}
-
-	go func() {
-		_ = cmd.Wait()
-		stop()
-	}()
-
-	sigCh := make(chan os.Signal, 1)
-	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
-	go func() {
-		<-sigCh
-		stop()
-	}()
-
-	if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-		fmt.Fprintf(os.Stderr, "Dev proxy server error: %v\n", err)
-		stop()
-		os.Exit(1)
-	}
-
-	stop()
-}