@vercel/go 3.8.0 → 3.9.1

package/dist/index.js

@@ -1917,9 +1917,9 @@ var require_end_of_stream = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js
+// ../../node_modules/.pnpm/pump@3.0.4/node_modules/pump/index.js
 var require_pump = __commonJS({
-  "../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js"(exports, module2) {
+  "../../node_modules/.pnpm/pump@3.0.4/node_modules/pump/index.js"(exports, module2) {
     var once2 = require_once();
     var eos = require_end_of_stream();
     var fs3;
@@ -1929,7 +1929,7 @@ var require_pump = __commonJS({
     }
     var noop = function() {
     };
-    var ancient = /^v?\.0/.test(process.version);
+    var ancient = typeof process === "undefined" ? false : /^v?\.0/.test(process.version);
     var isFn = function(fn2) {
       return typeof fn2 === "function";
     };
@@ -3453,13 +3453,13 @@ var require_clone = __commonJS({
       if (obj === null || typeof obj !== "object")
         return obj;
       if (obj instanceof Object)
-        var copy4 = { __proto__: getPrototypeOf(obj) };
+        var copy3 = { __proto__: getPrototypeOf(obj) };
       else
-        var copy4 = /* @__PURE__ */ Object.create(null);
+        var copy3 = /* @__PURE__ */ Object.create(null);
       Object.getOwnPropertyNames(obj).forEach(function(key) {
-        Object.defineProperty(copy4, key, Object.getOwnPropertyDescriptor(obj, key));
+        Object.defineProperty(copy3, key, Object.getOwnPropertyDescriptor(obj, key));
       });
-      return copy4;
+      return copy3;
     }
   }
 });
@@ -3549,8 +3549,8 @@ var require_graceful_fs = __commonJS({
       fs4.createReadStream = createReadStream;
       fs4.createWriteStream = createWriteStream2;
       var fs$readFile = fs4.readFile;
-      fs4.readFile = readFile4;
-      function readFile4(path, options, cb) {
+      fs4.readFile = readFile3;
+      function readFile3(path, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$readFile(path, options, cb);
@@ -4376,7 +4376,7 @@ var require_copy = __commonJS({
     var pathExists5 = require_path_exists().pathExists;
     var utimes = require_utimes().utimesMillis;
     var notExist = Symbol("notExist");
-    function copy4(src, dest, opts, cb) {
+    function copy3(src, dest, opts, cb) {
       if (typeof opts === "function" && !cb) {
         cb = opts;
         opts = {};
@@ -4602,7 +4602,7 @@ var require_copy = __commonJS({
         return cb(null, destStat);
       });
     }
-    module2.exports = copy4;
+    module2.exports = copy3;
   }
 });
 
@@ -5274,7 +5274,7 @@ var require_jsonfile = __commonJS({
     } catch (_2) {
       _fs = require("fs");
     }
-    function readFile4(file, options, callback) {
+    function readFile3(file, options, callback) {
       if (callback == null) {
         callback = options;
         options = {};
@@ -5373,7 +5373,7 @@ var require_jsonfile = __commonJS({
       return content;
     }
     var jsonfile = {
-      readFile: readFile4,
+      readFile: readFile3,
       readFileSync,
       writeFile: writeFile2,
       writeFileSync
@@ -5573,7 +5573,7 @@ var require_move = __commonJS({
     var u2 = require_universalify().fromCallback;
     var fs3 = require_graceful_fs();
     var path = require("path");
-    var copy4 = require_copy2().copy;
+    var copy3 = require_copy2().copy;
     var remove3 = require_remove().remove;
     var mkdirp3 = require_mkdirs2().mkdirp;
     var pathExists5 = require_path_exists().pathExists;
@@ -5630,7 +5630,7 @@ var require_move = __commonJS({
         overwrite,
         errorOnExist: true
       };
-      copy4(src, dest, opts, (err) => {
+      copy3(src, dest, opts, (err) => {
         if (err)
           return cb(err);
         return remove3(src, cb);
@@ -7498,9 +7498,9 @@ var require_public_api = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/node-fetch@2.6.7/node_modules/node-fetch/lib/index.js
+// ../../node_modules/.pnpm/node-fetch@2.6.9/node_modules/node-fetch/lib/index.js
 var require_lib4 = __commonJS({
-  "../../node_modules/.pnpm/node-fetch@2.6.7/node_modules/node-fetch/lib/index.js"(exports, module2) {
+  "../../node_modules/.pnpm/node-fetch@2.6.9/node_modules/node-fetch/lib/index.js"(exports, module2) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     function _interopDefault(ex) {
@@ -8495,6 +8495,11 @@ var require_lib4 = __commonJS({
       const dest = new URL$1(destination).hostname;
       return orig === dest || orig[orig.length - dest.length - 1] === "." && orig.endsWith(dest);
     };
+    var isSameProtocol = function isSameProtocol2(destination, original) {
+      const orig = new URL$1(original).protocol;
+      const dest = new URL$1(destination).protocol;
+      return orig === dest;
+    };
     function fetch(url, opts) {
       if (!fetch.Promise) {
         throw new Error("native promise missing, set fetch.Promise to your favorite alternative");
@@ -8510,7 +8515,7 @@ var require_lib4 = __commonJS({
           let error = new AbortError("The user aborted a request.");
           reject(error);
           if (request.body && request.body instanceof Stream.Readable) {
-            request.body.destroy(error);
+            destroyStream(request.body, error);
           }
           if (!response || !response.body)
             return;
@@ -8545,8 +8550,31 @@ var require_lib4 = __commonJS({
         }
         req.on("error", function(err) {
           reject(new FetchError(`request to ${request.url} failed, reason: ${err.message}`, "system", err));
+          if (response && response.body) {
+            destroyStream(response.body, err);
+          }
           finalize();
         });
+        fixResponseChunkedTransferBadEnding(req, function(err) {
+          if (signal && signal.aborted) {
+            return;
+          }
+          if (response && response.body) {
+            destroyStream(response.body, err);
+          }
+        });
+        if (parseInt(process.version.substring(1)) < 14) {
+          req.on("socket", function(s3) {
+            s3.addListener("close", function(hadError) {
+              const hasDataListener = s3.listenerCount("data") > 0;
+              if (response && hasDataListener && !hadError && !(signal && signal.aborted)) {
+                const err = new Error("Premature close");
+                err.code = "ERR_STREAM_PREMATURE_CLOSE";
+                response.body.emit("error", err);
+              }
+            });
+          });
+        }
         req.on("response", function(res) {
           clearTimeout(reqTimeout);
           const headers = createHeadersLenient(res.headers);
@@ -8597,7 +8625,7 @@ var require_lib4 = __commonJS({
                   timeout: request.timeout,
                   size: request.size
                 };
-                if (!isDomainOrSubdomain(request.url, locationURL)) {
+                if (!isDomainOrSubdomain(request.url, locationURL) || !isSameProtocol(request.url, locationURL)) {
                   for (const name of ["authorization", "www-authenticate", "cookie", "cookie2"]) {
                     requestOpts.headers.delete(name);
                   }
@@ -8658,6 +8686,12 @@ var require_lib4 = __commonJS({
               response = new Response(body, response_options);
               resolve(response);
             });
+            raw.on("end", function() {
+              if (!response) {
+                response = new Response(body, response_options);
+                resolve(response);
+              }
+            });
             return;
           }
           if (codings == "br" && typeof zlib.createBrotliDecompress === "function") {
@@ -8672,6 +8706,33 @@ var require_lib4 = __commonJS({
         writeToStream(req, request);
       });
     }
+    function fixResponseChunkedTransferBadEnding(request, errorCallback) {
+      let socket;
+      request.on("socket", function(s3) {
+        socket = s3;
+      });
+      request.on("response", function(response) {
+        const headers = response.headers;
+        if (headers["transfer-encoding"] === "chunked" && !headers["content-length"]) {
+          response.once("close", function(hadError) {
+            const hasDataListener = socket.listenerCount("data") > 0;
+            if (hasDataListener && !hadError) {
+              const err = new Error("Premature close");
+              err.code = "ERR_STREAM_PREMATURE_CLOSE";
+              errorCallback(err);
+            }
+          });
+        }
+      });
+    }
+    function destroyStream(stream, err) {
+      if (stream.destroy) {
+        stream.destroy(err);
+      } else {
+        stream.emit("error", err);
+        stream.end();
+      }
+    }
     fetch.isRedirect = function(code) {
       return code === 301 || code === 302 || code === 303 || code === 307 || code === 308;
     };
@@ -10877,6 +10938,84 @@ var require_xdg_app_paths = __commonJS({
   }
 });
 
+// ../../internals/ipc-proxy/dist/index.js
+var require_dist2 = __commonJS({
+  "../../internals/ipc-proxy/dist/index.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 src_exports2 = {};
+    __export2(src_exports2, {
+      createStandaloneLambda: () => createStandaloneLambda2,
+      getBootstrapDir: () => getBootstrapDir,
+      getProxyBinaryPath: () => getProxyBinaryPath
+    });
+    module2.exports = __toCommonJS2(src_exports2);
+    var import_node_path10 = require("path");
+    var import_node_fs7 = require("fs");
+    var import_promises2 = require("fs/promises");
+    var import_build_utils6 = require("@vercel/build-utils");
+    function proxyBinaryName(architecture) {
+      return architecture === "arm64" ? "proxy-linux-arm64" : "proxy-linux-amd64";
+    }
+    function getProxyBinaryPath(architecture) {
+      const binPath = (0, import_node_path10.join)(__dirname, "..", "bin", proxyBinaryName(architecture));
+      if (!(0, import_node_fs7.existsSync)(binPath)) {
+        throw new Error(
+          `IPC proxy binary not found for architecture "${architecture}" at ${binPath}. Ensure @vercel-internals/ipc-proxy has been built and its prebuilt binaries copied alongside the consumer's dist output.`
+        );
+      }
+      return binPath;
+    }
+    function getBootstrapDir() {
+      return (0, import_node_path10.join)(__dirname, "..", "bootstrap");
+    }
+    async function createStandaloneLambda2(options) {
+      const {
+        userServerPath,
+        architecture,
+        lambdaOptions,
+        includedFiles,
+        runtimeLanguage,
+        supportsResponseStreaming = true
+      } = options;
+      const proxyPath = getProxyBinaryPath(architecture);
+      const [proxyData, userServerData] = await Promise.all([
+        (0, import_promises2.readFile)(proxyPath),
+        (0, import_promises2.readFile)(userServerPath)
+      ]);
+      return new import_build_utils6.Lambda({
+        ...lambdaOptions,
+        files: {
+          ...includedFiles,
+          executable: new import_build_utils6.FileBlob({ mode: 493, data: proxyData }),
+          "user-server": new import_build_utils6.FileBlob({ mode: 493, data: userServerData })
+        },
+        handler: "executable",
+        runtime: "executable",
+        supportsResponseStreaming,
+        architecture,
+        runtimeLanguage
+      });
+    }
+  }
+});
+
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
@@ -10886,7 +11025,7 @@ __export(src_exports, {
   diagnostics: () => diagnostics,
   getNewHandlerFunctionName: () => getNewHandlerFunctionName,
   prepareCache: () => prepareCache,
-  shouldServe: () => import_build_utils5.shouldServe,
+  shouldServe: () => shouldServe,
   startDevServer: () => startDevServer,
   version: () => version
 });
@@ -14665,9 +14804,11 @@ 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");
+var import_ipc_proxy = __toESM(require_dist2());
 
 // src/diagnostics.ts
 var import_build_utils3 = require("@vercel/build-utils");
@@ -14802,7 +14943,6 @@ async function buildStandaloneServer({
   });
   const outDir = await (0, import_build_utils4.getWriteableDirectory)();
   const userServerPath = (0, import_path6.join)(outDir, "user-server");
-  const bootstrapPath = (0, import_path6.join)(outDir, "executable");
   const vendorModulesPath = (0, import_path6.join)(workPath, "vendor", "modules.txt");
   const isVendored = await (0, import_fs_extra3.pathExists)(vendorModulesPath);
   if (isVendored) {
@@ -14829,35 +14969,6 @@ async function buildStandaloneServer({
       throw err;
     }
   }
-  const bootstrapDir = (0, import_path6.join)(__dirname, "../bootstrap");
-  const bootstrapSrc = (0, import_path6.join)(bootstrapDir, "vc-init.go");
-  const utilsSrc = (0, import_path6.join)(bootstrapDir, "vc-utils.go");
-  const bootstrapGoModSrc = (0, import_path6.join)(bootstrapDir, "go.mod");
-  (0, import_build_utils4.debug)(`Building bootstrap wrapper: ${bootstrapSrc} -> ${bootstrapPath}`);
-  try {
-    const bootstrapBuildDir = await (0, import_build_utils4.getWriteableDirectory)();
-    const bootstrapGoFile = (0, import_path6.join)(bootstrapBuildDir, "main.go");
-    await (0, import_fs_extra3.copy)(bootstrapSrc, bootstrapGoFile);
-    await (0, import_fs_extra3.copy)(utilsSrc, (0, import_path6.join)(bootstrapBuildDir, "vc-utils.go"));
-    await (0, import_fs_extra3.copy)(bootstrapGoModSrc, (0, import_path6.join)(bootstrapBuildDir, "go.mod"));
-    const bootstrapEnv = {
-      PATH: process.env.PATH || "",
-      HOME: process.env.HOME || "",
-      TMPDIR: process.env.TMPDIR || "",
-      GOARCH: architecture === "arm64" ? "arm64" : "amd64",
-      GOOS: "linux",
-      CGO_ENABLED: "0"
-    };
-    const bootstrapGo = await createGo({
-      modulePath: bootstrapBuildDir,
-      opts: { cwd: bootstrapBuildDir, env: bootstrapEnv },
-      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];
@@ -14868,24 +14979,13 @@ async function buildStandaloneServer({
       }
     }
   }
-  const [userServerData, bootstrapData] = await Promise.all([
-    (0, import_fs_extra3.readFile)(userServerPath),
-    (0, import_fs_extra3.readFile)(bootstrapPath)
-  ]);
-  const lambda = new import_build_utils4.Lambda({
-    ...lambdaOptions,
-    files: {
-      ...includedFiles,
-      // Bootstrap is the main entrypoint (handles IPC protocol)
-      executable: new import_build_utils4.FileBlob({ mode: 493, data: bootstrapData }),
-      // User's server is spawned by bootstrap
-      "user-server": new import_build_utils4.FileBlob({ mode: 493, data: userServerData })
-    },
-    handler: "executable",
-    runtime: "executable",
-    supportsResponseStreaming: true,
+  const lambda = await (0, import_ipc_proxy.createStandaloneLambda)({
+    userServerPath,
     architecture,
-    runtimeLanguage: "go"
+    lambdaOptions,
+    includedFiles,
+    runtimeLanguage: "go",
+    supportsResponseStreaming: true
   });
   const preDeployCommand = config?.preDeployCommand;
   if (registerPreDeploy && typeof preDeployCommand === "string") {
@@ -14909,69 +15009,194 @@ async function buildStandaloneServer({
   });
   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_utils4.cloneEnv)(process.env, meta.env, {
-    PORT: String(port)
-  });
-  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/vc-utils.go");
-  (0, import_build_utils4.debug)(
-    `Starting standalone Go dev server wrapper: go run ${devWrapper} (target ${runTarget}, port ${port})`
-  );
-  const child = (0, import_child_process.spawn)("go", ["run", "-tags", "vcdev", devWrapper, devUtils], {
-    cwd: workPath,
-    env: {
-      ...env,
-      __VC_GO_DEV_RUN_TARGET: runTarget
-    },
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  child.stdout?.on("data", (data) => {
-    const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
-    if (opts.onStdout) {
-      opts.onStdout(chunk);
+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) {
+  try {
+    if (process.platform === "win32") {
+      process.kill(pid, "SIGTERM");
     } else {
-      process.stdout.write(chunk.toString());
+      process.kill(-pid, "SIGTERM");
     }
-  });
-  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());
+  } catch (err) {
+    (0, import_build_utils4.debug)(`Error killing standalone Go dev server ${pid}: ${err}`);
+  }
+}
+function installGlobalCleanupHandlers() {
+  if (cleanupHandlersInstalled)
+    return;
+  cleanupHandlersInstalled = true;
+  const killAll = () => {
+    for (const [key, info] of PERSISTENT_SERVERS.entries()) {
+      killStandaloneDevServer(info.pid);
+      PERSISTENT_SERVERS.delete(key);
     }
+  };
+  process.on("SIGINT", () => {
+    killAll();
   });
-  await new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      cleanup();
-      resolve();
-    }, 2e3);
-    const onExit = (code, signal) => {
-      cleanup();
-      reject(
-        new Error(
-          `Standalone Go dev server exited before startup completed (code: ${code}, signal: ${signal})`
-        )
-      );
-    };
-    const cleanup = () => {
-      clearTimeout(timeout);
-      child.removeListener("exit", onExit);
-    };
-    child.once("exit", onExit);
+  process.on("SIGTERM", () => {
+    killAll();
   });
-  return {
-    port,
-    pid: child.pid
+  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;
+      }
+      await sleep(100);
+    }
+    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 serverKey = `${workPath}::${resolvedEntrypoint}`;
+  const existing = PERSISTENT_SERVERS.get(serverKey);
+  if (existing) {
+    return {
+      port: existing.port,
+      pid: existing.pid,
+      shutdown: async () => {
+      }
+    };
+  }
+  const pending = PENDING_STARTS.get(serverKey);
+  if (pending) {
+    const { port, pid } = await pending;
+    return { port, pid, shutdown: async () => {
+    } };
+  }
+  const startPromise = (async () => {
+    const port = Math.floor(Math.random() * (65535 - 49152) + 49152);
+    const env = (0, import_build_utils4.cloneEnv)(process.env, meta.env, {
+      PORT: String(port)
+    });
+    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
+    });
+    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 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());
+      }
+    });
+    const pid = child.pid;
+    try {
+      await waitForPort(port, child, DEV_SERVER_STARTUP_TIMEOUT);
+    } catch (err) {
+      if (pid) {
+        killStandaloneDevServer(pid);
+      }
+      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);
+    });
+    installGlobalCleanupHandlers();
+    return { port, pid };
+  })();
+  PENDING_STARTS.set(serverKey, startPromise);
+  try {
+    const { port, pid } = await startPromise;
+    return { port, pid, shutdown: async () => {
+    } };
+  } finally {
+    PENDING_STARTS.delete(serverKey);
+  }
 }
 
 // src/index.ts
 var TMP = (0, import_os2.tmpdir)();
+var shouldServe = (opts) => {
+  const framework = opts.config.framework;
+  if (framework === "go" || framework === "services") {
+    return true;
+  }
+  return (0, import_build_utils5.shouldServe)(opts);
+};
 var MAIN_GO_FILENAME = "main__vc__go__.go";
 var HANDLER_FILENAME = `bootstrap${OUT_EXTENSION}`;
 async function initPrivateGit(credentials) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/go",
-  "version": "3.8.0",
+  "version": "3.9.1",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/go",
@@ -12,6 +12,7 @@
   "files": [
     "dist",
     "*.go",
+    "bin",
     "bootstrap"
   ],
   "devDependencies": {
@@ -31,10 +32,11 @@
     "vitest": "2.0.3",
     "xdg-app-paths": "5.1.0",
     "yauzl-promise": "2.1.3",
-    "@vercel/build-utils": "13.26.2"
+    "@vercel-internals/ipc-proxy": "1.0.0",
+    "@vercel/build-utils": "13.30.0"
   },
   "scripts": {
-    "build": "node ../../utils/build-builder.mjs",
+    "build": "node build.mjs",
     "test": "vitest run --config ../../vitest.config.mts",
     "test-e2e": "pnpm test test/integration-*",
     "type-check": "tsc --noEmit",

package/bootstrap/go.mod

@@ -1,3 +0,0 @@
-module vc-init
-
-go 1.23

package/bootstrap/vc-init.go

@@ -1,274 +0,0 @@
-// vc-init.go - Bootstrap wrapper for standalone Go servers on Vercel
-// This handles the IPC protocol required for executable runtime mode.
-//
-// The bootstrap:
-// 1. Connects to VERCEL_IPC_PATH Unix socket
-// 2. Starts the user's server on an internal port
-// 3. Sends "server-started" IPC message
-// 4. Reverse proxies requests to user's server
-// 5. Handles /_vercel/ping health check
-// 6. Sends "end" IPC message after each request
-
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"net"
-	"net/http"
-	"net/http/httputil"
-	"net/url"
-	"os"
-	"os/exec"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-)
-
-// IPC message types
-type StartMessage struct {
-	Type    string       `json:"type"`
-	Payload StartPayload `json:"payload"`
-}
-
-type StartPayload struct {
-	InitDuration int `json:"initDuration"`
-	HTTPPort     int `json:"httpPort"`
-}
-
-type EndMessage struct {
-	Type    string     `json:"type"`
-	Payload EndPayload `json:"payload"`
-}
-
-type EndPayload struct {
-	Context RequestContext `json:"context"`
-	Error   interface{}    `json:"error,omitempty"`
-}
-
-type RequestContext struct {
-	InvocationID string `json:"invocationId"`
-	RequestID    uint64 `json:"requestId"`
-}
-
-type UnrecoverableErrorMessage struct {
-	Type    string                    `json:"type"`
-	Payload UnrecoverableErrorPayload `json:"payload"`
-}
-
-type UnrecoverableErrorPayload struct {
-	ExitCode int    `json:"exitCode"`
-	Message  string `json:"message"`
-}
-
-var (
-	ipcConn   net.Conn
-	ipcMutex  sync.Mutex
-	ipcReady  bool
-	startTime time.Time
-)
-
-func sendIPCMessage(msg interface{}) error {
-	if ipcConn == nil {
-		return nil
-	}
-
-	ipcMutex.Lock()
-	defer ipcMutex.Unlock()
-
-	data, err := json.Marshal(msg)
-	if err != nil {
-		return err
-	}
-
-	// IPC messages are JSON followed by null byte
-	_, err = ipcConn.Write(append(data, 0))
-	return err
-}
-
-// fatal reports a fatal init error via IPC and exits.
-func fatal(exitCode int, msg string) {
-	fmt.Fprintln(os.Stderr, msg)
-	sendIPCMessage(UnrecoverableErrorMessage{
-		Type: "unrecoverable-error",
-		Payload: UnrecoverableErrorPayload{
-			ExitCode: exitCode,
-			Message:  msg,
-		},
-	})
-	os.Exit(exitCode)
-}
-
-func connectIPC() error {
-	ipcPath := os.Getenv("VERCEL_IPC_PATH")
-	if ipcPath == "" {
-		// No IPC path - running in dev mode or locally
-		return nil
-	}
-
-	conn, err := net.Dial("unix", ipcPath)
-	if err != nil {
-		return fmt.Errorf("failed to connect to IPC socket: %w", err)
-	}
-
-	ipcConn = conn
-	return nil
-}
-
-func main() {
-	startTime = time.Now()
-	serviceRoutePrefix := resolveServiceRoutePrefix()
-
-	// Connect to IPC socket
-	if err := connectIPC(); err != nil {
-		fmt.Fprintf(os.Stderr, "Warning: %v\n", err)
-	}
-
-	// Find a free port for the user's server
-	userPort, err := findFreePort()
-	if err != nil {
-		fatal(1, fmt.Sprintf("Failed to find free port: %v", err))
-	}
-
-	// Start the user's server binary
-	userBinary := "./user-server"
-	if _, err := os.Stat(userBinary); os.IsNotExist(err) {
-		fatal(1, fmt.Sprintf("User server binary not found: %s", userBinary))
-	}
-
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
-
-	cmd := exec.CommandContext(ctx, userBinary)
-	cmd.Env = append(os.Environ(), fmt.Sprintf("PORT=%d", userPort))
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-
-	if err := cmd.Start(); err != nil {
-		fatal(1, fmt.Sprintf("Failed to start user server: %v", err))
-	}
-
-	// Race server readiness against early child death.
-	childDone := make(chan error, 1)
-	go func() { childDone <- cmd.Wait() }()
-
-	serverReady := make(chan error, 1)
-	go func() { serverReady <- waitForServer(userPort, 30*time.Second) }()
-
-	select {
-	case waitErr := <-childDone:
-		// Child exited before the server became ready.
-		exitCode := 1
-		var exitErr *exec.ExitError
-		if errors.As(waitErr, &exitErr) {
-			exitCode = exitErr.ExitCode()
-		}
-		fatal(exitCode, "User server exited during startup")
-	case err := <-serverReady:
-		if err != nil {
-			cmd.Process.Kill()
-			fatal(1, fmt.Sprintf("User server failed to start: %v", err))
-		}
-	}
-
-	// Create reverse proxy to user's server
-	targetURL, _ := url.Parse(fmt.Sprintf("http://127.0.0.1:%d", userPort))
-	proxy := httputil.NewSingleHostReverseProxy(targetURL)
-
-	// Customize the proxy director to preserve headers
-	originalDirector := proxy.Director
-	proxy.Director = func(req *http.Request) {
-		originalDirector(req)
-		// Preserve the original Host header
-		if host := req.Header.Get("X-Forwarded-Host"); host != "" {
-			req.Host = host
-		}
-	}
-
-	// The port we'll listen on (Vercel will route traffic here)
-	listenPort := 3000
-
-	// Create HTTP server with IPC-aware handler
-	server := &http.Server{
-		Addr: fmt.Sprintf("127.0.0.1:%d", listenPort),
-		Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			// Handle Vercel health check
-			if r.URL.Path == "/_vercel/ping" {
-				w.WriteHeader(http.StatusOK)
-				w.Write([]byte("OK"))
-				return
-			}
-
-			// Extract Vercel internal headers
-			invocationID := r.Header.Get("X-Vercel-Internal-Invocation-Id")
-			requestIDStr := r.Header.Get("X-Vercel-Internal-Request-Id")
-			requestID, _ := strconv.ParseUint(requestIDStr, 10, 64)
-
-			// Remove internal headers before forwarding
-			for key := range r.Header {
-				if strings.HasPrefix(strings.ToLower(key), "x-vercel-internal-") {
-					r.Header.Del(key)
-				}
-			}
-
-			if r.URL != nil {
-				originalPath := r.URL.Path
-				r.URL.Path = stripServiceRoutePrefix(r.URL.Path, serviceRoutePrefix)
-				if r.URL.Path != originalPath {
-					// Keep URL path encoding fields consistent after rewrite.
-					r.URL.RawPath = ""
-				}
-			}
-
-			// Forward request to user's server
-			proxy.ServeHTTP(w, r)
-
-			// Send end message via IPC
-			if ipcConn != nil && invocationID != "" {
-				endMsg := EndMessage{
-					Type: "end",
-					Payload: EndPayload{
-						Context: RequestContext{
-							InvocationID: invocationID,
-							RequestID:    requestID,
-						},
-					},
-				}
-				sendIPCMessage(endMsg)
-			}
-		}),
-	}
-
-	// Send server-started IPC message
-	initDuration := int(time.Since(startTime).Milliseconds())
-	startMsg := StartMessage{
-		Type: "server-started",
-		Payload: StartPayload{
-			InitDuration: initDuration,
-			HTTPPort:     listenPort,
-		},
-	}
-
-	if err := sendIPCMessage(startMsg); err != nil {
-		fmt.Fprintf(os.Stderr, "Warning: Failed to send IPC start message: %v\n", err)
-	} else {
-		ipcReady = true
-	}
-
-	// If no IPC, print the port for local development
-	if ipcConn == nil {
-		fmt.Printf("Server listening on port %d (proxying to user server on port %d)\n", listenPort, userPort)
-	}
-
-	// Start the proxy server
-	if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-		fmt.Fprintf(os.Stderr, "Server error: %v\n", err)
-		os.Exit(1)
-	}
-
-	// Clean up
-	cmd.Process.Kill()
-}