@vercel/go 3.11.0 → 5.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) {
@@ -10938,6 +10938,288 @@ var require_xdg_app_paths = __commonJS({
   }
 });
 
+// ../../internals/ipc-proxy/dist/dev-proxy.js
+var require_dev_proxy = __commonJS({
+  "../../internals/ipc-proxy/dist/dev-proxy.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to2, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to2, key) && key !== except)
+            __defProp2(to2, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to2;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var dev_proxy_exports = {};
+    __export2(dev_proxy_exports, {
+      createDevProxyServer: () => createDevProxyServer,
+      findFreePort: () => findFreePort,
+      normalizeServiceRoutePrefix: () => normalizeServiceRoutePrefix,
+      resolveServiceRoutePrefix: () => resolveServiceRoutePrefix,
+      rewriteRequestUrl: () => rewriteRequestUrl,
+      sanitizeHeaders: () => sanitizeHeaders,
+      startDevProxy: () => startDevProxy2,
+      stripServiceRoutePrefix: () => stripServiceRoutePrefix,
+      waitForPort: () => waitForPort
+    });
+    module2.exports = __toCommonJS2(dev_proxy_exports);
+    var import_node_http = require("http");
+    var import_node_net = require("net");
+    var PING_PATH = "/_vercel/ping";
+    var INTERNAL_HEADER_PREFIX = "x-vercel-internal-";
+    var LOCALHOST = "127.0.0.1";
+    var DEFAULT_READINESS_TIMEOUT = 5 * 6e4;
+    var READINESS_POLL_INTERVAL = 100;
+    var READINESS_DIAL_TIMEOUT = 1e3;
+    function normalizeServiceRoutePrefix(rawPrefix) {
+      if (!rawPrefix)
+        return "";
+      let prefix = rawPrefix.trim();
+      if (!prefix)
+        return "";
+      if (!prefix.startsWith("/")) {
+        prefix = `/${prefix}`;
+      }
+      if (prefix !== "/") {
+        prefix = prefix.replace(/\/+$/, "");
+        if (!prefix)
+          prefix = "/";
+      }
+      return prefix === "/" ? "" : prefix;
+    }
+    function resolveServiceRoutePrefix(env = process.env) {
+      const strip = (env.VERCEL_SERVICE_ROUTE_PREFIX_STRIP ?? "").trim().toLowerCase();
+      if (strip !== "1" && strip !== "true")
+        return "";
+      return normalizeServiceRoutePrefix(env.VERCEL_SERVICE_ROUTE_PREFIX);
+    }
+    function stripServiceRoutePrefix(pathValue, prefix) {
+      if (pathValue === "*")
+        return pathValue;
+      let normalized = pathValue;
+      if (!normalized) {
+        normalized = "/";
+      } else if (!normalized.startsWith("/")) {
+        normalized = `/${normalized}`;
+      }
+      if (!prefix)
+        return normalized;
+      if (normalized === prefix)
+        return "/";
+      if (normalized.startsWith(`${prefix}/`)) {
+        return normalized.slice(prefix.length) || "/";
+      }
+      return normalized;
+    }
+    function splitUrl(url) {
+      const queryIndex = url.indexOf("?");
+      if (queryIndex === -1)
+        return { pathname: url, search: "" };
+      return { pathname: url.slice(0, queryIndex), search: url.slice(queryIndex) };
+    }
+    function rewriteRequestUrl(url, prefix) {
+      const { pathname, search } = splitUrl(url || "/");
+      return `${stripServiceRoutePrefix(pathname, prefix)}${search}`;
+    }
+    function sanitizeHeaders(headers) {
+      const sanitized = {};
+      for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase().startsWith(INTERNAL_HEADER_PREFIX))
+          continue;
+        sanitized[key] = value;
+      }
+      const forwardedHost = headers["x-forwarded-host"];
+      const host = Array.isArray(forwardedHost) ? forwardedHost[0] : forwardedHost;
+      if (host) {
+        sanitized.host = host;
+      }
+      return sanitized;
+    }
+    function findFreePort() {
+      return new Promise((resolve, reject) => {
+        const server = (0, import_node_net.createServer)();
+        server.unref();
+        server.once("error", reject);
+        server.listen(0, LOCALHOST, () => {
+          const address = server.address();
+          if (!address || typeof address === "string") {
+            server.close(() => reject(new Error("Failed to allocate a free port")));
+            return;
+          }
+          const { port } = address;
+          server.close(() => resolve(port));
+        });
+      });
+    }
+    function isPortReachable(port) {
+      return new Promise((resolve) => {
+        const socket = (0, import_node_net.createConnection)({ port, host: LOCALHOST });
+        const done = (reachable) => {
+          socket.removeAllListeners();
+          socket.destroy();
+          resolve(reachable);
+        };
+        socket.setTimeout(READINESS_DIAL_TIMEOUT);
+        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, label = "Dev server") {
+      let exited;
+      let spawnError;
+      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) {
+            throw new Error(
+              `${label} exited before it started listening (code: ${exited.code}, signal: ${exited.signal})`
+            );
+          }
+          if (await isPortReachable(port))
+            return;
+          await sleep(READINESS_POLL_INTERVAL);
+        }
+        throw new Error(`${label} did not start listening within ${timeout}ms`);
+      } finally {
+        child.removeListener("exit", onExit);
+        child.removeListener("error", onError);
+      }
+    }
+    function createDevProxyServer(options) {
+      const { targetPort } = options;
+      const routePrefix = normalizeServiceRoutePrefix(options.routePrefix);
+      const server = (0, import_node_http.createServer)((req, res) => {
+        const { pathname } = splitUrl(req.url || "/");
+        if (pathname === PING_PATH) {
+          res.writeHead(200, { "content-type": "text/plain" });
+          res.end("OK");
+          return;
+        }
+        const proxyReq = (0, import_node_http.request)(
+          {
+            host: LOCALHOST,
+            port: targetPort,
+            method: req.method,
+            path: rewriteRequestUrl(req.url || "/", routePrefix),
+            headers: sanitizeHeaders(req.headers)
+          },
+          (proxyRes) => {
+            res.writeHead(proxyRes.statusCode ?? 502, proxyRes.headers);
+            proxyRes.pipe(res);
+          }
+        );
+        proxyReq.once("error", (err) => {
+          if (!res.headersSent) {
+            res.writeHead(502, { "content-type": "text/plain" });
+          }
+          res.end(`Dev proxy error: ${err.message}`);
+        });
+        res.once("close", () => {
+          if (!res.writableFinished)
+            proxyReq.destroy();
+        });
+        req.pipe(proxyReq);
+      });
+      server.on("upgrade", (req, clientSocket, head) => {
+        const headers = sanitizeHeaders(req.headers);
+        const path = rewriteRequestUrl(req.url || "/", routePrefix);
+        const upstream = (0, import_node_net.createConnection)(
+          { host: LOCALHOST, port: targetPort },
+          () => {
+            const lines = [`${req.method} ${path} HTTP/${req.httpVersion}`];
+            for (const [key, value] of Object.entries(headers)) {
+              if (Array.isArray(value)) {
+                for (const entry of value)
+                  lines.push(`${key}: ${entry}`);
+              } else if (value !== void 0) {
+                lines.push(`${key}: ${value}`);
+              }
+            }
+            upstream.write(`${lines.join("\r\n")}\r
+\r
+`);
+            if (head?.length)
+              upstream.write(new Uint8Array(head));
+            upstream.pipe(clientSocket);
+            clientSocket.pipe(upstream);
+          }
+        );
+        const destroy = () => {
+          upstream.destroy();
+          clientSocket.destroy();
+        };
+        upstream.once("error", destroy);
+        clientSocket.once("error", destroy);
+      });
+      return server;
+    }
+    async function startDevProxy2(options) {
+      const {
+        spawnServer,
+        env = process.env,
+        readinessTimeout = DEFAULT_READINESS_TIMEOUT,
+        label = "Dev server"
+      } = options;
+      const internalPort = await findFreePort();
+      const child = spawnServer(internalPort);
+      let server;
+      const close = async () => {
+        if (server) {
+          await new Promise((resolve) => {
+            server?.close(() => resolve());
+            server?.closeAllConnections?.();
+          });
+        }
+        if (child.exitCode === null && child.signalCode === null) {
+          child.kill("SIGTERM");
+        }
+      };
+      try {
+        await waitForPort(internalPort, child, readinessTimeout, label);
+        server = createDevProxyServer({
+          targetPort: internalPort,
+          routePrefix: resolveServiceRoutePrefix(env)
+        });
+        const listenPort = options.port ?? await findFreePort();
+        await new Promise((resolve, reject) => {
+          server?.once("error", reject);
+          server?.listen(listenPort, () => resolve());
+        });
+        if (!child.pid) {
+          throw new Error(`${label} started without a PID`);
+        }
+        return { port: listenPort, pid: child.pid, child, close };
+      } catch (err) {
+        await close();
+        throw err;
+      }
+    }
+  }
+});
+
 // ../../internals/ipc-proxy/dist/index.js
 var require_dist2 = __commonJS({
   "../../internals/ipc-proxy/dist/index.js"(exports, module2) {
@@ -10958,6 +11240,7 @@ var require_dist2 = __commonJS({
       }
       return to2;
     };
+    var __reExport = (target, mod, secondTarget) => (__copyProps2(target, mod, "default"), secondTarget && __copyProps2(secondTarget, mod, "default"));
     var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
     var src_exports2 = {};
     __export2(src_exports2, {
@@ -10970,6 +11253,7 @@ var require_dist2 = __commonJS({
     var import_node_fs7 = require("fs");
     var import_promises2 = require("fs/promises");
     var import_build_utils6 = require("@vercel/build-utils");
+    __reExport(src_exports2, require_dev_proxy(), module2.exports);
     function proxyBinaryName(architecture) {
       return architecture === "arm64" ? "proxy-linux-arm64" : "proxy-linux-amd64";
     }
@@ -14469,27 +14753,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;
@@ -14804,7 +15136,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");
@@ -15049,19 +15380,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() {
@@ -15069,162 +15410,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();
-  });
-}
-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));
+  process.on("SIGINT", killAll);
+  process.on("SIGTERM", killAll);
+  process.on("exit", killAll);
 }
-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);
+    }
   }
 }
 
@@ -15883,9 +16213,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": "3.11.0",
+  "version": "5.0.0",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/go",
@@ -12,9 +12,12 @@
   "files": [
     "dist",
     "*.go",
-    "bin",
-    "bootstrap"
+    "bin"
   ],
+  "dependencies": {},
+  "peerDependencies": {
+    "@vercel/build-utils": "14.4.0"
+  },
   "devDependencies": {
     "@tootallnate/once": "1.1.2",
     "@types/async-retry": "1.4.5",
@@ -32,13 +35,14 @@
     "vitest": "4.1.10",
     "xdg-app-paths": "5.1.0",
     "yauzl-promise": "2.1.3",
-    "@vercel-internals/ipc-proxy": "1.0.0",
-    "@vercel/build-utils": "14.0.5"
+    "@vercel/build-utils": "14.4.0",
+    "@vercel-internals/ipc-proxy": "1.0.0"
   },
   "scripts": {
     "build": "node build.mjs",
     "test": "vitest run --config ../../vitest.config.mts",
     "test-e2e": "vitest run --config ../../vitest.config.mts test/integration-",
+    "test-e2e-builder": "pnpm run test-e2e",
     "type-check": "tsc --noEmit"
   }
 }

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()
-}