@vercel/ruby 2.2.1 → 2.2.2

package/dist/index.js

@@ -174,8 +174,8 @@ var require_isexe = __commonJS({
 // ../../node_modules/.pnpm/which@1.3.1/node_modules/which/which.js
 var require_which = __commonJS({
   "../../node_modules/.pnpm/which@1.3.1/node_modules/which/which.js"(exports, module2) {
-    module2.exports = which2;
-    which2.sync = whichSync;
+    module2.exports = which3;
+    which3.sync = whichSync;
     var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
     var path = require("path");
     var COLON = isWindows ? ";" : ":";
@@ -206,7 +206,7 @@ var require_which = __commonJS({
         extExe: pathExtExe
       };
     }
-    function which2(cmd, opt, cb) {
+    function which3(cmd, opt, cb) {
       if (typeof opt === "function") {
         cb = opt;
         opt = {};
@@ -307,7 +307,7 @@ var require_resolveCommand = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@6.0.5/node_modules/cross-spawn/lib/util/resolveCommand.js"(exports, module2) {
     "use strict";
     var path = require("path");
-    var which2 = require_which();
+    var which3 = require_which();
     var pathKey = require_path_key()();
     function resolveCommandAttempt(parsed, withoutPathExt) {
       const cwd = process.cwd();
@@ -320,7 +320,7 @@ var require_resolveCommand = __commonJS({
       }
       let resolved;
       try {
-        resolved = which2.sync(parsed.command, {
+        resolved = which3.sync(parsed.command, {
           path: (parsed.options.env || process.env)[pathKey],
           pathExt: withoutPathExt ? path.delimiter : void 0
         });
@@ -423,15 +423,15 @@ var require_readShebang = __commonJS({
 var require_semver = __commonJS({
   "../../node_modules/.pnpm/semver@5.7.2/node_modules/semver/semver.js"(exports, module2) {
     exports = module2.exports = SemVer;
-    var debug3;
+    var debug4;
     if (typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
-      debug3 = function() {
+      debug4 = function() {
         var args = Array.prototype.slice.call(arguments, 0);
         args.unshift("SEMVER");
         console.log.apply(console, args);
       };
     } else {
-      debug3 = function() {
+      debug4 = function() {
       };
     }
     exports.SEMVER_SPEC_VERSION = "2.0.0";
@@ -540,7 +540,7 @@ var require_semver = __commonJS({
     var STAR = R++;
     src[STAR] = "(<|>)?=?\\s*\\*";
     for (i = 0; i < R; i++) {
-      debug3(i, src[i]);
+      debug4(i, src[i]);
       if (!re[i]) {
         re[i] = new RegExp(src[i]);
         safeRe[i] = new RegExp(makeSafeRe(src[i]));
@@ -607,7 +607,7 @@ var require_semver = __commonJS({
       if (!(this instanceof SemVer)) {
         return new SemVer(version2, options);
       }
-      debug3("SemVer", version2, options);
+      debug4("SemVer", version2, options);
       this.options = options;
       this.loose = !!options.loose;
       var m = version2.trim().match(options.loose ? safeRe[LOOSE] : safeRe[FULL]);
@@ -654,7 +654,7 @@ var require_semver = __commonJS({
       return this.version;
     };
     SemVer.prototype.compare = function(other) {
-      debug3("SemVer.compare", this.version, this.options, other);
+      debug4("SemVer.compare", this.version, this.options, other);
       if (!(other instanceof SemVer)) {
         other = new SemVer(other, this.options);
       }
@@ -681,7 +681,7 @@ var require_semver = __commonJS({
       do {
         var a = this.prerelease[i2];
         var b = other.prerelease[i2];
-        debug3("prerelease compare", i2, a, b);
+        debug4("prerelease compare", i2, a, b);
         if (a === void 0 && b === void 0) {
           return 0;
         } else if (b === void 0) {
@@ -695,8 +695,8 @@ var require_semver = __commonJS({
         }
       } while (++i2);
     };
-    SemVer.prototype.inc = function(release, identifier) {
-      switch (release) {
+    SemVer.prototype.inc = function(release2, identifier) {
+      switch (release2) {
         case "premajor":
           this.prerelease.length = 0;
           this.patch = 0;
@@ -768,20 +768,20 @@ var require_semver = __commonJS({
           }
           break;
         default:
-          throw new Error("invalid increment argument: " + release);
+          throw new Error("invalid increment argument: " + release2);
       }
       this.format();
       this.raw = this.version;
       return this;
     };
     exports.inc = inc;
-    function inc(version2, release, loose, identifier) {
+    function inc(version2, release2, loose, identifier) {
       if (typeof loose === "string") {
         identifier = loose;
         loose = void 0;
       }
       try {
-        return new SemVer(version2, loose).inc(release, identifier).version;
+        return new SemVer(version2, loose).inc(release2, identifier).version;
       } catch (er) {
         return null;
       }
@@ -935,7 +935,7 @@ var require_semver = __commonJS({
         return new Comparator(comp, options);
       }
       comp = comp.trim().split(/\s+/).join(" ");
-      debug3("comparator", comp, options);
+      debug4("comparator", comp, options);
       this.options = options;
       this.loose = !!options.loose;
       this.parse(comp);
@@ -944,7 +944,7 @@ var require_semver = __commonJS({
       } else {
         this.value = this.operator + this.semver.version;
       }
-      debug3("comp", this);
+      debug4("comp", this);
     }
     var ANY = {};
     Comparator.prototype.parse = function(comp) {
@@ -967,7 +967,7 @@ var require_semver = __commonJS({
       return this.value;
     };
     Comparator.prototype.test = function(version2) {
-      debug3("Comparator.test", version2, this.options.loose);
+      debug4("Comparator.test", version2, this.options.loose);
       if (this.semver === ANY) {
         return true;
       }
@@ -1050,9 +1050,9 @@ var require_semver = __commonJS({
       var loose = this.options.loose;
       var hr = loose ? safeRe[HYPHENRANGELOOSE] : safeRe[HYPHENRANGE];
       range = range.replace(hr, hyphenReplace);
-      debug3("hyphen replace", range);
+      debug4("hyphen replace", range);
       range = range.replace(safeRe[COMPARATORTRIM], comparatorTrimReplace);
-      debug3("comparator trim", range, safeRe[COMPARATORTRIM]);
+      debug4("comparator trim", range, safeRe[COMPARATORTRIM]);
       range = range.replace(safeRe[TILDETRIM], tildeTrimReplace);
       range = range.replace(safeRe[CARETTRIM], caretTrimReplace);
       var compRe = loose ? safeRe[COMPARATORLOOSE] : safeRe[COMPARATOR];
@@ -1092,15 +1092,15 @@ var require_semver = __commonJS({
       });
     }
     function parseComparator(comp, options) {
-      debug3("comp", comp, options);
+      debug4("comp", comp, options);
       comp = replaceCarets(comp, options);
-      debug3("caret", comp);
+      debug4("caret", comp);
       comp = replaceTildes(comp, options);
-      debug3("tildes", comp);
+      debug4("tildes", comp);
       comp = replaceXRanges(comp, options);
-      debug3("xrange", comp);
+      debug4("xrange", comp);
       comp = replaceStars(comp, options);
-      debug3("stars", comp);
+      debug4("stars", comp);
       return comp;
     }
     function isX(id) {
@@ -1114,7 +1114,7 @@ var require_semver = __commonJS({
     function replaceTilde(comp, options) {
       var r = options.loose ? safeRe[TILDELOOSE] : safeRe[TILDE];
       return comp.replace(r, function(_, M, m, p, pr) {
-        debug3("tilde", comp, _, M, m, p, pr);
+        debug4("tilde", comp, _, M, m, p, pr);
         var ret;
         if (isX(M)) {
           ret = "";
@@ -1123,12 +1123,12 @@ var require_semver = __commonJS({
         } else if (isX(p)) {
           ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
         } else if (pr) {
-          debug3("replaceTilde pr", pr);
+          debug4("replaceTilde pr", pr);
           ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
         } else {
           ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
         }
-        debug3("tilde return", ret);
+        debug4("tilde return", ret);
         return ret;
       });
     }
@@ -1138,10 +1138,10 @@ var require_semver = __commonJS({
       }).join(" ");
     }
     function replaceCaret(comp, options) {
-      debug3("caret", comp, options);
+      debug4("caret", comp, options);
       var r = options.loose ? safeRe[CARETLOOSE] : safeRe[CARET];
       return comp.replace(r, function(_, M, m, p, pr) {
-        debug3("caret", comp, _, M, m, p, pr);
+        debug4("caret", comp, _, M, m, p, pr);
         var ret;
         if (isX(M)) {
           ret = "";
@@ -1154,7 +1154,7 @@ var require_semver = __commonJS({
             ret = ">=" + M + "." + m + ".0 <" + (+M + 1) + ".0.0";
           }
         } else if (pr) {
-          debug3("replaceCaret pr", pr);
+          debug4("replaceCaret pr", pr);
           if (M === "0") {
             if (m === "0") {
               ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + m + "." + (+p + 1);
@@ -1165,7 +1165,7 @@ var require_semver = __commonJS({
             ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + (+M + 1) + ".0.0";
           }
         } else {
-          debug3("no pr");
+          debug4("no pr");
           if (M === "0") {
             if (m === "0") {
               ret = ">=" + M + "." + m + "." + p + " <" + M + "." + m + "." + (+p + 1);
@@ -1176,12 +1176,12 @@ var require_semver = __commonJS({
             ret = ">=" + M + "." + m + "." + p + " <" + (+M + 1) + ".0.0";
           }
         }
-        debug3("caret return", ret);
+        debug4("caret return", ret);
         return ret;
       });
     }
     function replaceXRanges(comp, options) {
-      debug3("replaceXRanges", comp, options);
+      debug4("replaceXRanges", comp, options);
       return comp.split(/\s+/).map(function(comp2) {
         return replaceXRange(comp2, options);
       }).join(" ");
@@ -1190,7 +1190,7 @@ var require_semver = __commonJS({
       comp = comp.trim();
       var r = options.loose ? safeRe[XRANGELOOSE] : safeRe[XRANGE];
       return comp.replace(r, function(ret, gtlt, M, m, p, pr) {
-        debug3("xRange", comp, ret, gtlt, M, m, p, pr);
+        debug4("xRange", comp, ret, gtlt, M, m, p, pr);
         var xM = isX(M);
         var xm = xM || isX(m);
         var xp = xm || isX(p);
@@ -1233,12 +1233,12 @@ var require_semver = __commonJS({
         } else if (xp) {
           ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
         }
-        debug3("xRange return", ret);
+        debug4("xRange return", ret);
         return ret;
       });
     }
     function replaceStars(comp, options) {
-      debug3("replaceStars", comp, options);
+      debug4("replaceStars", comp, options);
       return comp.trim().replace(safeRe[STAR], "");
     }
     function hyphenReplace($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) {
@@ -1286,7 +1286,7 @@ var require_semver = __commonJS({
       }
       if (version2.prerelease.length && !options.includePrerelease) {
         for (i2 = 0; i2 < set.length; i2++) {
-          debug3(set[i2].semver);
+          debug4(set[i2].semver);
           if (set[i2].semver === ANY) {
             continue;
           }
@@ -1631,21 +1631,21 @@ var require_cross_spawn = __commonJS({
     var cp = require("child_process");
     var parse = require_parse();
     var enoent = require_enoent();
-    function spawn(command, args, options) {
+    function spawn2(command, args, options) {
       const parsed = parse(command, args, options);
       const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
       return spawned;
     }
-    function spawnSync(command, args, options) {
+    function spawnSync2(command, args, options) {
       const parsed = parse(command, args, options);
       const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
     }
-    module2.exports = spawn;
-    module2.exports.spawn = spawn;
-    module2.exports.sync = spawnSync;
+    module2.exports = spawn2;
+    module2.exports.spawn = spawn2;
+    module2.exports.sync = spawnSync2;
     module2.exports._parse = parse;
     module2.exports._enoent = enoent;
   }
@@ -3465,11 +3465,11 @@ var require_graceful_fs = __commonJS({
         }
       });
     }
-    var debug3 = noop;
+    var debug4 = noop;
     if (util.debuglog)
-      debug3 = util.debuglog("gfs4");
+      debug4 = util.debuglog("gfs4");
     else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
-      debug3 = function() {
+      debug4 = function() {
         var m = util.format.apply(util, arguments);
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
@@ -3504,7 +3504,7 @@ var require_graceful_fs = __commonJS({
       }(fs.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug3(fs[gracefulQueue]);
+          debug4(fs[gracefulQueue]);
           require("assert").equal(fs[gracefulQueue].length, 0);
         });
       }
@@ -3757,7 +3757,7 @@ var require_graceful_fs = __commonJS({
       return fs2;
     }
     function enqueue(elem) {
-      debug3("ENQUEUE", elem[0].name, elem[1]);
+      debug4("ENQUEUE", elem[0].name, elem[1]);
       fs[gracefulQueue].push(elem);
       retry();
     }
@@ -3784,10 +3784,10 @@ var require_graceful_fs = __commonJS({
       var startTime = elem[3];
       var lastTime = elem[4];
       if (startTime === void 0) {
-        debug3("RETRY", fn.name, args);
+        debug4("RETRY", fn.name, args);
         fn.apply(null, args);
       } else if (Date.now() - startTime >= 6e4) {
-        debug3("TIMEOUT", fn.name, args);
+        debug4("TIMEOUT", fn.name, args);
         var cb = args.pop();
         if (typeof cb === "function")
           cb.call(null, err);
@@ -3796,7 +3796,7 @@ var require_graceful_fs = __commonJS({
         var sinceStart = Math.max(lastTime - startTime, 1);
         var desiredDelay = Math.min(sinceStart * 1.2, 100);
         if (sinceAttempt >= desiredDelay) {
-          debug3("RETRY", fn.name, args);
+          debug4("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
           fs[gracefulQueue].push(elem);
@@ -5281,7 +5281,7 @@ var require_jsonfile = __commonJS({
         callback(null, obj);
       });
     }
-    function readFileSync(file, options) {
+    function readFileSync2(file, options) {
       options = options || {};
       if (typeof options === "string") {
         options = { encoding: options };
@@ -5335,7 +5335,7 @@ var require_jsonfile = __commonJS({
       }
       fs.writeFile(file, str, options, callback);
     }
-    function writeFileSync(file, obj, options) {
+    function writeFileSync2(file, obj, options) {
       options = options || {};
       var fs = options.fs || _fs;
       var str = stringify(obj, options);
@@ -5349,9 +5349,9 @@ var require_jsonfile = __commonJS({
     }
     var jsonfile = {
       readFile: readFile2,
-      readFileSync,
+      readFileSync: readFileSync2,
       writeFile: writeFile2,
-      writeFileSync
+      writeFileSync: writeFileSync2
     };
     module2.exports = jsonfile;
   }
@@ -5702,7 +5702,7 @@ var require_lib = __commonJS({
 var require_lib2 = __commonJS({
   "../../node_modules/.pnpm/which@3.0.0/node_modules/which/lib/index.js"(exports, module2) {
     var isexe = require_isexe();
-    var { join: join3, delimiter, sep, posix } = require("path");
+    var { join: join4, delimiter, sep, posix } = require("path");
     var isWindows = process.platform === "win32";
     var rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? "" : sep}]`.replace(/(\\)/g, "\\$1"));
     var rRel = new RegExp(`^\\.${rSlash.source}`);
@@ -5731,9 +5731,9 @@ var require_lib2 = __commonJS({
     var getPathPart = (raw, cmd) => {
       const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
       const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
-      return prefix + join3(pathPart, cmd);
+      return prefix + join4(pathPart, cmd);
     };
-    var which2 = async (cmd, opt = {}) => {
+    var which3 = async (cmd, opt = {}) => {
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
       const found = [];
       for (const envPart of pathEnv) {
@@ -5781,8 +5781,8 @@ var require_lib2 = __commonJS({
       }
       throw getNotFoundError(cmd);
     };
-    module2.exports = which2;
-    which2.sync = whichSync;
+    module2.exports = which3;
+    which3.sync = whichSync;
   }
 });
 
@@ -5790,15 +5790,15 @@ var require_lib2 = __commonJS({
 var require_semver2 = __commonJS({
   "../../node_modules/.pnpm/semver@6.3.1/node_modules/semver/semver.js"(exports, module2) {
     exports = module2.exports = SemVer;
-    var debug3;
+    var debug4;
     if (typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
-      debug3 = function() {
+      debug4 = function() {
         var args = Array.prototype.slice.call(arguments, 0);
         args.unshift("SEMVER");
         console.log.apply(console, args);
       };
     } else {
-      debug3 = function() {
+      debug4 = function() {
       };
     }
     exports.SEMVER_SPEC_VERSION = "2.0.0";
@@ -5916,7 +5916,7 @@ var require_semver2 = __commonJS({
     tok("STAR");
     src[t.STAR] = "(<|>)?=?\\s*\\*";
     for (i = 0; i < R; i++) {
-      debug3(i, src[i]);
+      debug4(i, src[i]);
       if (!re[i]) {
         re[i] = new RegExp(src[i]);
         safeRe[i] = new RegExp(makeSafeRe(src[i]));
@@ -5983,7 +5983,7 @@ var require_semver2 = __commonJS({
       if (!(this instanceof SemVer)) {
         return new SemVer(version2, options);
       }
-      debug3("SemVer", version2, options);
+      debug4("SemVer", version2, options);
       this.options = options;
       this.loose = !!options.loose;
       var m = version2.trim().match(options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL]);
@@ -6030,7 +6030,7 @@ var require_semver2 = __commonJS({
       return this.version;
     };
     SemVer.prototype.compare = function(other) {
-      debug3("SemVer.compare", this.version, this.options, other);
+      debug4("SemVer.compare", this.version, this.options, other);
       if (!(other instanceof SemVer)) {
         other = new SemVer(other, this.options);
       }
@@ -6057,7 +6057,7 @@ var require_semver2 = __commonJS({
       do {
         var a = this.prerelease[i2];
         var b = other.prerelease[i2];
-        debug3("prerelease compare", i2, a, b);
+        debug4("prerelease compare", i2, a, b);
         if (a === void 0 && b === void 0) {
           return 0;
         } else if (b === void 0) {
@@ -6079,7 +6079,7 @@ var require_semver2 = __commonJS({
       do {
         var a = this.build[i2];
         var b = other.build[i2];
-        debug3("prerelease compare", i2, a, b);
+        debug4("prerelease compare", i2, a, b);
         if (a === void 0 && b === void 0) {
           return 0;
         } else if (b === void 0) {
@@ -6093,8 +6093,8 @@ var require_semver2 = __commonJS({
         }
       } while (++i2);
     };
-    SemVer.prototype.inc = function(release, identifier) {
-      switch (release) {
+    SemVer.prototype.inc = function(release2, identifier) {
+      switch (release2) {
         case "premajor":
           this.prerelease.length = 0;
           this.patch = 0;
@@ -6166,20 +6166,20 @@ var require_semver2 = __commonJS({
           }
           break;
         default:
-          throw new Error("invalid increment argument: " + release);
+          throw new Error("invalid increment argument: " + release2);
       }
       this.format();
       this.raw = this.version;
       return this;
     };
     exports.inc = inc;
-    function inc(version2, release, loose, identifier) {
+    function inc(version2, release2, loose, identifier) {
       if (typeof loose === "string") {
         identifier = loose;
         loose = void 0;
       }
       try {
-        return new SemVer(version2, loose).inc(release, identifier).version;
+        return new SemVer(version2, loose).inc(release2, identifier).version;
       } catch (er) {
         return null;
       }
@@ -6339,7 +6339,7 @@ var require_semver2 = __commonJS({
         return new Comparator(comp, options);
       }
       comp = comp.trim().split(/\s+/).join(" ");
-      debug3("comparator", comp, options);
+      debug4("comparator", comp, options);
       this.options = options;
       this.loose = !!options.loose;
       this.parse(comp);
@@ -6348,7 +6348,7 @@ var require_semver2 = __commonJS({
       } else {
         this.value = this.operator + this.semver.version;
       }
-      debug3("comp", this);
+      debug4("comp", this);
     }
     var ANY = {};
     Comparator.prototype.parse = function(comp) {
@@ -6371,7 +6371,7 @@ var require_semver2 = __commonJS({
       return this.value;
     };
     Comparator.prototype.test = function(version2) {
-      debug3("Comparator.test", version2, this.options.loose);
+      debug4("Comparator.test", version2, this.options.loose);
       if (this.semver === ANY || version2 === ANY) {
         return true;
       }
@@ -6464,9 +6464,9 @@ var require_semver2 = __commonJS({
       var loose = this.options.loose;
       var hr = loose ? safeRe[t.HYPHENRANGELOOSE] : safeRe[t.HYPHENRANGE];
       range = range.replace(hr, hyphenReplace);
-      debug3("hyphen replace", range);
+      debug4("hyphen replace", range);
       range = range.replace(safeRe[t.COMPARATORTRIM], comparatorTrimReplace);
-      debug3("comparator trim", range, safeRe[t.COMPARATORTRIM]);
+      debug4("comparator trim", range, safeRe[t.COMPARATORTRIM]);
       range = range.replace(safeRe[t.TILDETRIM], tildeTrimReplace);
       range = range.replace(safeRe[t.CARETTRIM], caretTrimReplace);
       range = range.split(/\s+/).join(" ");
@@ -6519,15 +6519,15 @@ var require_semver2 = __commonJS({
       });
     }
     function parseComparator(comp, options) {
-      debug3("comp", comp, options);
+      debug4("comp", comp, options);
       comp = replaceCarets(comp, options);
-      debug3("caret", comp);
+      debug4("caret", comp);
       comp = replaceTildes(comp, options);
-      debug3("tildes", comp);
+      debug4("tildes", comp);
       comp = replaceXRanges(comp, options);
-      debug3("xrange", comp);
+      debug4("xrange", comp);
       comp = replaceStars(comp, options);
-      debug3("stars", comp);
+      debug4("stars", comp);
       return comp;
     }
     function isX(id) {
@@ -6541,7 +6541,7 @@ var require_semver2 = __commonJS({
     function replaceTilde(comp, options) {
       var r = options.loose ? safeRe[t.TILDELOOSE] : safeRe[t.TILDE];
       return comp.replace(r, function(_, M, m, p, pr) {
-        debug3("tilde", comp, _, M, m, p, pr);
+        debug4("tilde", comp, _, M, m, p, pr);
         var ret;
         if (isX(M)) {
           ret = "";
@@ -6550,12 +6550,12 @@ var require_semver2 = __commonJS({
         } else if (isX(p)) {
           ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
         } else if (pr) {
-          debug3("replaceTilde pr", pr);
+          debug4("replaceTilde pr", pr);
           ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
         } else {
           ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
         }
-        debug3("tilde return", ret);
+        debug4("tilde return", ret);
         return ret;
       });
     }
@@ -6565,10 +6565,10 @@ var require_semver2 = __commonJS({
       }).join(" ");
     }
     function replaceCaret(comp, options) {
-      debug3("caret", comp, options);
+      debug4("caret", comp, options);
       var r = options.loose ? safeRe[t.CARETLOOSE] : safeRe[t.CARET];
       return comp.replace(r, function(_, M, m, p, pr) {
-        debug3("caret", comp, _, M, m, p, pr);
+        debug4("caret", comp, _, M, m, p, pr);
         var ret;
         if (isX(M)) {
           ret = "";
@@ -6581,7 +6581,7 @@ var require_semver2 = __commonJS({
             ret = ">=" + M + "." + m + ".0 <" + (+M + 1) + ".0.0";
           }
         } else if (pr) {
-          debug3("replaceCaret pr", pr);
+          debug4("replaceCaret pr", pr);
           if (M === "0") {
             if (m === "0") {
               ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + m + "." + (+p + 1);
@@ -6592,7 +6592,7 @@ var require_semver2 = __commonJS({
             ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + (+M + 1) + ".0.0";
           }
         } else {
-          debug3("no pr");
+          debug4("no pr");
           if (M === "0") {
             if (m === "0") {
               ret = ">=" + M + "." + m + "." + p + " <" + M + "." + m + "." + (+p + 1);
@@ -6603,12 +6603,12 @@ var require_semver2 = __commonJS({
             ret = ">=" + M + "." + m + "." + p + " <" + (+M + 1) + ".0.0";
           }
         }
-        debug3("caret return", ret);
+        debug4("caret return", ret);
         return ret;
       });
     }
     function replaceXRanges(comp, options) {
-      debug3("replaceXRanges", comp, options);
+      debug4("replaceXRanges", comp, options);
       return comp.split(/\s+/).map(function(comp2) {
         return replaceXRange(comp2, options);
       }).join(" ");
@@ -6617,7 +6617,7 @@ var require_semver2 = __commonJS({
       comp = comp.trim();
       var r = options.loose ? safeRe[t.XRANGELOOSE] : safeRe[t.XRANGE];
       return comp.replace(r, function(ret, gtlt, M, m, p, pr) {
-        debug3("xRange", comp, ret, gtlt, M, m, p, pr);
+        debug4("xRange", comp, ret, gtlt, M, m, p, pr);
         var xM = isX(M);
         var xm = xM || isX(m);
         var xp = xm || isX(p);
@@ -6661,12 +6661,12 @@ var require_semver2 = __commonJS({
         } else if (xp) {
           ret = ">=" + M + "." + m + ".0" + pr + " <" + M + "." + (+m + 1) + ".0" + pr;
         }
-        debug3("xRange return", ret);
+        debug4("xRange return", ret);
         return ret;
       });
     }
     function replaceStars(comp, options) {
-      debug3("replaceStars", comp, options);
+      debug4("replaceStars", comp, options);
       return comp.trim().replace(safeRe[t.STAR], "");
     }
     function hyphenReplace($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) {
@@ -6718,7 +6718,7 @@ var require_semver2 = __commonJS({
       }
       if (version2.prerelease.length && !options.includePrerelease) {
         for (i2 = 0; i2 < set.length; i2++) {
-          debug3(set[i2].semver);
+          debug4(set[i2].semver);
           if (set[i2].semver === ANY) {
             continue;
           }
@@ -6940,14 +6940,16 @@ var require_semver2 = __commonJS({
 var src_exports = {};
 __export(src_exports, {
   build: () => build,
+  shouldServe: () => shouldServe,
+  startDevServer: () => startDevServer,
   version: () => version
 });
 module.exports = __toCommonJS(src_exports);
-var import_os = require("os");
-var import_path2 = require("path");
+var import_os2 = require("os");
+var import_path3 = require("path");
 var import_execa2 = __toESM(require_execa());
 var import_fs_extra = __toESM(require_lib());
-var import_build_utils2 = require("@vercel/build-utils");
+var import_build_utils3 = require("@vercel/build-utils");
 
 // src/install-ruby.ts
 var import_execa = __toESM(require_execa());
@@ -6955,6 +6957,8 @@ var import_which = __toESM(require_lib2());
 var import_path = require("path");
 var import_semver = __toESM(require_semver2());
 var import_build_utils = require("@vercel/build-utils");
+var import_child_process = require("child_process");
+var import_os = require("os");
 var RubyVersion = class extends import_build_utils.Version {
 };
 var allOptions = [
@@ -6996,12 +7000,68 @@ function getLatestRubyVersion() {
   }
   return selection;
 }
+function resolveSystemRuby() {
+  const rubyPath = import_which.default.sync("ruby", { nothrow: true });
+  const gemPath = import_which.default.sync("gem", { nothrow: true });
+  if (!rubyPath || !gemPath)
+    return null;
+  const ver = (0, import_child_process.spawnSync)(rubyPath, ["-e", "print RUBY_VERSION"], {
+    encoding: "utf8"
+  });
+  if (ver.status !== 0 || !ver.stdout)
+    return null;
+  const [mj, mn] = String(ver.stdout).trim().split(".");
+  const major = Number(mj) ?? 3;
+  const minor = Number(mn) ?? 3;
+  return { rubyPath, gemPath, major, minor };
+}
+function makeLocalRubyEnv({
+  major,
+  minor,
+  rubyPath,
+  gemPath
+}) {
+  const gemHome = (0, import_path.join)((0, import_os.tmpdir)(), `vercel-ruby-${major}${minor}-${process.pid}`);
+  const matchedOption = allOptions.find(
+    (o) => o.major === major && o.minor === minor && o.state !== "discontinued"
+  );
+  if (!matchedOption) {
+    throw new import_build_utils.NowBuildError({
+      code: "RUBY_INVALID_VERSION",
+      link: "http://vercel.link/ruby-version",
+      message: `Local Ruby ${major}.${minor} does not match any supported Vercel runtime. Supported: ${allOptions.filter((o) => o.state !== "discontinued").map((o) => `${o.major}.${o.minor}`).join(", ")}`
+    });
+  }
+  return {
+    major,
+    gemHome,
+    runtime: matchedOption.runtime,
+    rubyPath,
+    gemPath,
+    vendorPath: `vendor/bundle/ruby/${major}.${minor}.0`
+  };
+}
 function getRubyPath(meta, gemfileContents) {
-  let selection = getLatestRubyVersion();
+  let selection = null;
+  try {
+    selection = getLatestRubyVersion();
+  } catch {
+    selection = null;
+  }
   if (meta.isDev) {
-    throw new Error(
-      "Ruby is in the early alpha stage and does not support vercel dev at this time."
-    );
+    const sys2 = resolveSystemRuby();
+    if (sys2) {
+      const result = makeLocalRubyEnv(sys2);
+      (0, import_build_utils.debug)(
+        `ruby: using system ruby for local dev: ${JSON.stringify({ ruby: sys2.rubyPath, gem: sys2.gemPath, version: `${sys2.major}.${sys2.minor}` })}`
+      );
+      return result;
+    }
+    throw new import_build_utils.NowBuildError({
+      code: "RUBY_INVALID_VERSION",
+      link: "http://vercel.link/ruby-version",
+      message: "Unable to find any supported Ruby versions (local). Ensure ruby and gem are on PATH."
+    });
   } else if (gemfileContents) {
     const line = gemfileContents.split("\n").find((line2) => line2.startsWith("ruby"));
     if (line) {
@@ -7017,30 +7077,60 @@ function getRubyPath(meta, gemfileContents) {
           link: "http://vercel.link/ruby-version"
         });
       }
-      if (selection.state === "discontinued" || !isInstalled(selection)) {
-        const latest = getLatestRubyVersion();
-        const intro = `Found \`Gemfile\` with ${selection.state === "discontinued" ? "discontinued" : "invalid"} Ruby version: \`${line}.\``;
-        const hint = `Please set \`ruby "~> ${latest.range}"\` in your \`Gemfile\` to use Ruby ${latest.range}.`;
+      if (!selection || selection.state === "discontinued" || !isInstalled(selection)) {
+        const sys2 = resolveSystemRuby();
+        if (sys2) {
+          const sysRange = `${sys2.major}.${sys2.minor}.x`;
+          if (!strVersion || (0, import_semver.intersects)(sysRange, strVersion)) {
+            const result = makeLocalRubyEnv(sys2);
+            (0, import_build_utils.debug)(
+              `ruby: using system ruby (Gemfile) version=${sys2.major}.${sys2.minor} ruby=${sys2.rubyPath}`
+            );
+            return result;
+          }
+        }
+        let latest = null;
+        try {
+          latest = getLatestRubyVersion();
+        } catch {
+        }
+        const intro = `Found \`Gemfile\` with ${selection && selection.state === "discontinued" ? "discontinued" : "invalid"} Ruby version: \`${line}.\``;
+        const hint = latest ? `Please set \`ruby "~> ${latest.range}"\` in your \`Gemfile\` to use Ruby ${latest.range}.` : "Please update your `Gemfile` to use a supported Ruby version.";
         throw new import_build_utils.NowBuildError({
-          code: selection.state === "discontinued" ? "RUBY_DISCONTINUED_VERSION" : "RUBY_INVALID_VERSION",
+          code: selection && selection.state === "discontinued" ? "RUBY_DISCONTINUED_VERSION" : "RUBY_INVALID_VERSION",
           link: "http://vercel.link/ruby-version",
           message: `${intro} ${hint}`
         });
       }
     }
   }
-  const { major, minor, runtime } = selection;
-  const gemHome = "/ruby" + major + minor;
-  const result = {
-    major,
-    gemHome,
-    runtime,
-    rubyPath: (0, import_path.join)(gemHome, "bin", "ruby"),
-    gemPath: (0, import_path.join)(gemHome, "bin", "gem"),
-    vendorPath: `vendor/bundle/ruby/${major}.${minor}.0`
-  };
-  (0, import_build_utils.debug)(JSON.stringify(result, null, " "));
-  return result;
+  if (selection) {
+    const { major, minor, runtime } = selection;
+    const gemHome = "/ruby" + major + minor;
+    const result = {
+      major,
+      gemHome,
+      runtime,
+      rubyPath: (0, import_path.join)(gemHome, "bin", "ruby"),
+      gemPath: (0, import_path.join)(gemHome, "bin", "gem"),
+      vendorPath: `vendor/bundle/ruby/${major}.${minor}.0`
+    };
+    (0, import_build_utils.debug)(JSON.stringify(result, null, " "));
+    return result;
+  }
+  const sys = resolveSystemRuby();
+  if (sys) {
+    const result = makeLocalRubyEnv(sys);
+    (0, import_build_utils.debug)(
+      `ruby: using system ruby (fallback) version=${sys.major}.${sys.minor} ruby=${sys.rubyPath}`
+    );
+    return result;
+  }
+  throw new import_build_utils.NowBuildError({
+    code: "RUBY_INVALID_VERSION",
+    link: "http://vercel.link/ruby-version",
+    message: "Unable to find any supported Ruby versions."
+  });
 }
 async function installBundler(meta, gemfileContents) {
   const { gemHome, rubyPath, gemPath, vendorPath, runtime, major } = getRubyPath(meta, gemfileContents);
@@ -7066,6 +7156,292 @@ function isInstalled({ major, minor }) {
   return Boolean(import_which.default.sync((0, import_path.join)(gemHome, "bin/ruby"), { nothrow: true })) && Boolean(import_which.default.sync((0, import_path.join)(gemHome, "bin/gem"), { nothrow: true }));
 }
 
+// src/start-dev-server.ts
+var import_child_process2 = require("child_process");
+var import_fs = require("fs");
+var import_path2 = require("path");
+var import_which2 = __toESM(require_lib2());
+var import_build_utils2 = require("@vercel/build-utils");
+function silenceNodeWarnings() {
+  const original = process.emitWarning.bind(
+    process
+  );
+  let active = true;
+  const wrapped = (warning, ...args) => {
+    if (!active) {
+      return original(
+        warning,
+        ...args
+      );
+    }
+    return;
+  };
+  process.emitWarning = wrapped;
+  return () => {
+    if (!active)
+      return;
+    active = false;
+    if (process.emitWarning === wrapped) {
+      process.emitWarning = original;
+    }
+  };
+}
+var PERSISTENT_SERVERS = /* @__PURE__ */ new Map();
+var PENDING_STARTS = /* @__PURE__ */ new Map();
+var restoreWarnings = null;
+var cleanupHandlersInstalled = false;
+function installGlobalCleanupHandlers() {
+  if (cleanupHandlersInstalled)
+    return;
+  cleanupHandlersInstalled = true;
+  const killAll = () => {
+    for (const [key, info] of PERSISTENT_SERVERS.entries()) {
+      try {
+        process.kill(info.pid, "SIGTERM");
+      } catch (err) {
+        (0, import_build_utils2.debug)(`Error sending SIGTERM to ${info.pid}: ${err}`);
+      }
+      try {
+        process.kill(info.pid, "SIGKILL");
+      } catch (err) {
+        (0, import_build_utils2.debug)(`Error sending SIGKILL to ${info.pid}: ${err}`);
+      }
+      PERSISTENT_SERVERS.delete(key);
+    }
+    if (restoreWarnings) {
+      try {
+        restoreWarnings();
+      } catch (err) {
+        (0, import_build_utils2.debug)(`Error restoring warnings: ${err}`);
+      }
+      restoreWarnings = null;
+    }
+  };
+  process.on("SIGINT", () => {
+    killAll();
+    process.exit(130);
+  });
+  process.on("SIGTERM", () => {
+    killAll();
+    process.exit(143);
+  });
+  process.on("exit", () => {
+    killAll();
+  });
+}
+function createDevRubyShim(workPath, entrypoint) {
+  try {
+    const vercelRubyDir = (0, import_path2.join)(workPath, ".vercel", "ruby");
+    (0, import_fs.mkdirSync)(vercelRubyDir, { recursive: true });
+    const shimPath = (0, import_path2.join)(vercelRubyDir, `vc_init_dev.rb`);
+    const templatePath = (0, import_path2.join)(__dirname, "..", "vc_init_dev.rb");
+    const template = (0, import_fs.readFileSync)(templatePath, "utf8");
+    const shimSource = template.replace(/__VC_DEV_ENTRYPOINT__/g, entrypoint);
+    (0, import_fs.writeFileSync)(shimPath, shimSource, "utf8");
+    (0, import_build_utils2.debug)(`Prepared Ruby dev shim at ${shimPath}`);
+    return shimPath;
+  } catch (err) {
+    (0, import_build_utils2.debug)(`Failed to prepare Ruby dev shim: ${err?.message || err}`);
+    return null;
+  }
+}
+function detectGemfile(workPath, entrypoint) {
+  const entryDir = (0, import_path2.dirname)(entrypoint);
+  const localGemfile = (0, import_path2.join)(workPath, entryDir, "Gemfile");
+  if ((0, import_fs.existsSync)(localGemfile))
+    return localGemfile;
+  const rootGemfile = (0, import_path2.join)(workPath, "Gemfile");
+  if ((0, import_fs.existsSync)(rootGemfile))
+    return rootGemfile;
+  return null;
+}
+async function run(cmd, args, opts) {
+  return await new Promise((resolve) => {
+    const child = (0, import_child_process2.spawn)(cmd, args, {
+      cwd: opts.cwd,
+      env: opts.env,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    child.stdout?.on("data", (buf) => process.stdout.write(buf));
+    child.stderr?.on("data", (buf) => process.stderr.write(buf));
+    child.on("close", (code, signal) => resolve({ code, signal }));
+  });
+}
+var startDevServer = async (opts) => {
+  const { entrypoint: rawEntrypoint, workPath, meta = {} } = opts;
+  if (!rawEntrypoint.endsWith(".ru")) {
+    return null;
+  }
+  if (!restoreWarnings)
+    restoreWarnings = silenceNodeWarnings();
+  installGlobalCleanupHandlers();
+  const entrypoint = rawEntrypoint;
+  const env = { ...process.env, ...meta.env || {} };
+  const serverKey = `${workPath}::${entrypoint}::ruby`;
+  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 () => {
+    } };
+  }
+  let childProcess = null;
+  let stdoutLogListener = null;
+  let stderrLogListener = null;
+  let resolveChildReady;
+  let rejectChildReady;
+  const childReady = new Promise(
+    (resolve, reject) => {
+      resolveChildReady = resolve;
+      rejectChildReady = reject;
+    }
+  );
+  PENDING_STARTS.set(serverKey, childReady);
+  try {
+    await new Promise((resolve, reject) => {
+      let resolved = false;
+      const shimPath = createDevRubyShim(workPath, entrypoint);
+      if (!shimPath) {
+        rejectChildReady(
+          new import_build_utils2.NowBuildError({
+            code: "RUBY_DEV_SHIM_ERROR",
+            message: "Failed to create Ruby dev shim."
+          })
+        );
+        return reject(new Error("Failed to create Ruby dev shim"));
+      }
+      const gemfile = detectGemfile(workPath, entrypoint);
+      const bundlePath = import_which2.default.sync("bundle", { nothrow: true });
+      const bundlerPath = bundlePath || import_which2.default.sync("bundler", { nothrow: true });
+      const projectDir = gemfile ? (0, import_path2.dirname)(gemfile) : workPath;
+      if (gemfile) {
+        env.BUNDLE_GEMFILE = gemfile;
+      }
+      const checkDeps = async () => {
+        if (gemfile && bundlerPath) {
+          (0, import_build_utils2.debug)(`Running "bundle check" for ${gemfile}`);
+          const check = await run(
+            bundlerPath,
+            ["check", "--gemfile", gemfile],
+            { cwd: projectDir, env }
+          );
+          if (check.code !== 0) {
+            return false;
+          }
+        }
+        return true;
+      };
+      checkDeps().then((ok) => {
+        if (!ok) {
+          const err = new import_build_utils2.NowBuildError({
+            code: "RUBY_GEMS_MISSING",
+            message: 'Required gems are not installed. Run "vercel build" and try again.'
+          });
+          rejectChildReady(err);
+          return reject(err);
+        }
+        let cmd = "ruby";
+        let args = [shimPath];
+        if (gemfile && bundlerPath) {
+          cmd = bundlerPath;
+          args = ["exec", "ruby", shimPath];
+        }
+        (0, import_build_utils2.debug)(`Starting Ruby dev server: ${cmd} ${args.join(" ")}`);
+        const child = (0, import_child_process2.spawn)(cmd, args, {
+          cwd: workPath,
+          env,
+          stdio: ["inherit", "pipe", "pipe"]
+        });
+        childProcess = child;
+        stdoutLogListener = (buf) => {
+          const s = buf.toString();
+          for (const line of s.split(/\r?\n/)) {
+            if (line)
+              process.stdout.write(line.endsWith("\n") ? line : line + "\n");
+          }
+        };
+        stderrLogListener = (buf) => {
+          const s = buf.toString();
+          for (const line of s.split(/\r?\n/)) {
+            if (line)
+              process.stderr.write(line.endsWith("\n") ? line : line + "\n");
+          }
+        };
+        child.stdout?.on("data", stdoutLogListener);
+        child.stderr?.on("data", stderrLogListener);
+        const readinessRegexes = [
+          /Serving on https?:\/\/(?:\[[^\]]+\]|[^:\s]+):(\d+)/i,
+          /WEBrick.*?listening on.*?:(\d+)/i
+        ];
+        const onDetect = (chunk) => {
+          const text = chunk.toString();
+          let portMatch = null;
+          for (const rx of readinessRegexes) {
+            const m = text.match(rx);
+            if (m) {
+              portMatch = m;
+              break;
+            }
+          }
+          if (portMatch && child.pid) {
+            if (!resolved) {
+              resolved = true;
+              child.stdout?.removeListener("data", onDetect);
+              child.stderr?.removeListener("data", onDetect);
+              const port2 = Number(portMatch[1]);
+              resolveChildReady({ port: port2, pid: child.pid });
+              resolve();
+            }
+          }
+        };
+        child.stdout?.on("data", onDetect);
+        child.stderr?.on("data", onDetect);
+        child.once("error", (err) => {
+          if (!resolved) {
+            rejectChildReady(err);
+            reject(err);
+          }
+        });
+        child.once("exit", (code, signal) => {
+          if (!resolved) {
+            const err = new Error(
+              `Ruby dev server exited before binding (code=${code}, signal=${signal})`
+            );
+            rejectChildReady(err);
+            reject(err);
+          }
+        });
+      }).catch((err) => {
+        if (!resolved) {
+          rejectChildReady(err);
+          reject(err);
+        }
+      });
+    });
+    const { port, pid } = await childReady;
+    PERSISTENT_SERVERS.set(serverKey, {
+      port,
+      pid,
+      child: childProcess,
+      stdoutLogListener,
+      stderrLogListener
+    });
+    const shutdown = async () => {
+    };
+    return { port, pid, shutdown };
+  } finally {
+    PENDING_STARTS.delete(serverKey);
+  }
+};
+
 // src/index.ts
 async function matchPaths(configPatterns, workPath) {
   const patterns = typeof configPatterns === "string" ? [configPatterns] : configPatterns;
@@ -7074,65 +7450,98 @@ async function matchPaths(configPatterns, workPath) {
   }
   const patternPaths = await Promise.all(
     patterns.map(async (pattern) => {
-      const files = await (0, import_build_utils2.glob)(pattern, workPath);
+      const files = await (0, import_build_utils3.glob)(pattern, workPath);
       return Object.keys(files);
     })
   );
   return patternPaths.reduce((a, b) => a.concat(b), []);
 }
-async function bundleInstall(bundlePath, bundleDir, gemfilePath, rubyPath, major) {
-  (0, import_build_utils2.debug)(`running "bundle install --deployment"...`);
-  const bundleAppConfig = await (0, import_build_utils2.getWriteableDirectory)();
-  const gemfileContent = await (0, import_fs_extra.readFile)(gemfilePath, "utf8");
-  if (gemfileContent.includes('ruby "~> 2.7.x"')) {
-    await (0, import_fs_extra.writeFile)(
-      gemfilePath,
-      gemfileContent.replace('ruby "~> 2.7.x"', 'ruby "~> 2.7.0"')
-    );
-  } else if (gemfileContent.includes('ruby "~> 3.2.x"')) {
-    await (0, import_fs_extra.writeFile)(
-      gemfilePath,
-      gemfileContent.replace('ruby "~> 3.2.x"', 'ruby "~> 3.2.0"')
-    );
-  } else if (gemfileContent.includes('ruby "~> 3.3.x"')) {
-    await (0, import_fs_extra.writeFile)(
-      gemfilePath,
-      gemfileContent.replace('ruby "~> 3.3.x"', 'ruby "~> 3.3.0"')
-    );
+async function prepareGemfile(gemfilePath, major) {
+  let gemfile = await (0, import_fs_extra.readFile)(gemfilePath, "utf8");
+  let modified = false;
+  const patchRuby = (from, to) => {
+    if (gemfile.includes(from)) {
+      gemfile = gemfile.replace(from, to);
+      modified = true;
+    }
+  };
+  patchRuby('ruby "~> 3.3.x"', 'ruby "~> 3.3.0"');
+  patchRuby('ruby "~> 3.2.x"', 'ruby "~> 3.2.0"');
+  patchRuby('ruby "~> 2.7.x"', 'ruby "~> 2.7.0"');
+  const containsWebrick = /^[^#]*\bgem\s+["']webrick["']/m.test(gemfile);
+  if (major >= 3 && !containsWebrick) {
+    gemfile += `${import_os2.EOL}gem "webrick"${import_os2.EOL}`;
+    modified = true;
   }
-  const bundlerEnv = (0, import_build_utils2.cloneEnv)(process.env, {
-    // Ensure the correct version of `ruby` is in front of the $PATH
-    PATH: `${(0, import_path2.dirname)(rubyPath)}:${(0, import_path2.dirname)(bundlePath)}:${process.env.PATH}`,
+  if (modified) {
+    await (0, import_fs_extra.writeFile)(gemfilePath, gemfile);
+  }
+  return { modified };
+}
+async function bundleLock(bundlerPath, gemfilePath, rubyPath) {
+  const bundleAppConfig = await (0, import_build_utils3.getWriteableDirectory)();
+  const bundlerEnv = (0, import_build_utils3.cloneEnv)(process.env, {
+    PATH: `${(0, import_path3.dirname)(rubyPath)}:${(0, import_path3.dirname)(bundlerPath)}:${process.env.PATH}`,
     BUNDLE_SILENCE_ROOT_WARNING: "1",
     BUNDLE_APP_CONFIG: bundleAppConfig,
     BUNDLE_JOBS: "4"
   });
-  if (major >= 3) {
-    const result2 = await (0, import_execa2.default)("bundler", ["add", "webrick"], {
-      cwd: (0, import_path2.dirname)(gemfilePath),
-      stdio: "pipe",
-      env: bundlerEnv,
-      reject: false
-    });
-    if (result2.exitCode !== 0) {
-      console.log(result2.stdout);
-      console.error(result2.stderr);
-      throw result2;
-    }
+  const archTokenLinux = process.arch === "arm64" ? "aarch64" : "x86_64";
+  const linuxPlatform = `${archTokenLinux}-linux`;
+  const platforms = [linuxPlatform];
+  if (process.platform === "darwin") {
+    const darwinArchToken = process.arch === "arm64" ? "arm64" : "x86_64";
+    const darwinMajor = Number((0, import_os2.release)().split(".")[0]) || void 0;
+    const darwinPlatform = darwinMajor ? `${darwinArchToken}-darwin-${darwinMajor}` : `${darwinArchToken}-darwin`;
+    platforms.push(darwinPlatform);
+  }
+  (0, import_build_utils3.debug)(`ruby: ensuring Gemfile.lock has platforms ${platforms.join(", ")}`);
+  const lockArgs = ["lock"];
+  for (const platform of platforms) {
+    lockArgs.push("--add-platform", platform);
+  }
+  const lockRes = await (0, import_execa2.default)(bundlerPath, lockArgs, {
+    cwd: (0, import_path3.dirname)(gemfilePath),
+    stdio: "pipe",
+    env: bundlerEnv,
+    reject: false
+  });
+  if (lockRes.exitCode !== 0) {
+    console.log(lockRes.stdout);
+    console.error(lockRes.stderr);
+    throw lockRes;
   }
-  const result = await (0, import_execa2.default)(
+}
+async function bundleInstall(bundlePath, bundleDir, gemfilePath, rubyPath) {
+  const bundleAppConfig = await (0, import_build_utils3.getWriteableDirectory)();
+  const bundlerEnv = (0, import_build_utils3.cloneEnv)(process.env, {
+    PATH: `${(0, import_path3.dirname)(rubyPath)}:${(0, import_path3.dirname)(bundlePath)}:${process.env.PATH}`,
+    BUNDLE_SILENCE_ROOT_WARNING: "1",
+    BUNDLE_APP_CONFIG: bundleAppConfig,
+    BUNDLE_JOBS: "4"
+  });
+  (0, import_build_utils3.debug)('running "bundle install --deployment --frozen"');
+  const installRes = await (0, import_execa2.default)(
     bundlePath,
-    ["install", "--deployment", "--gemfile", gemfilePath, "--path", bundleDir],
+    [
+      "install",
+      "--deployment",
+      "--frozen",
+      "--gemfile",
+      gemfilePath,
+      "--path",
+      bundleDir
+    ],
     {
       stdio: "pipe",
       env: bundlerEnv,
       reject: false
     }
   );
-  if (result.exitCode !== 0) {
-    console.log(result.stdout);
-    console.error(result.stderr);
-    throw result;
+  if (installRes.exitCode !== 0) {
+    console.log(installRes.stdout);
+    console.error(installRes.stderr);
+    throw installRes;
   }
 }
 var version = 3;
@@ -7143,66 +7552,80 @@ var build = async ({
   config,
   meta = {}
 }) => {
-  await (0, import_build_utils2.download)(files, workPath, meta);
-  const entrypointFsDirname = (0, import_path2.join)(workPath, (0, import_path2.dirname)(entrypoint));
+  await (0, import_build_utils3.download)(files, workPath, meta);
+  const entrypointFsDirname = (0, import_path3.join)(workPath, (0, import_path3.dirname)(entrypoint));
   const gemfileName = "Gemfile";
-  let gemfilePath = await (0, import_build_utils2.walkParentDirs)({
+  let gemfilePath = await (0, import_build_utils3.walkParentDirs)({
     base: workPath,
     start: entrypointFsDirname,
     filename: gemfileName
   });
   if (!gemfilePath) {
-    gemfilePath = (0, import_path2.join)(entrypointFsDirname, gemfileName);
-    await (0, import_fs_extra.writeFile)(gemfilePath, `source "https://rubygems.org"${import_os.EOL}`);
+    gemfilePath = (0, import_path3.join)(entrypointFsDirname, gemfileName);
+    await (0, import_fs_extra.writeFile)(gemfilePath, `source "https://rubygems.org"${import_os2.EOL}`);
   }
   const gemfileContents = gemfilePath ? await (0, import_fs_extra.readFile)(gemfilePath, "utf8") : "";
   const { gemHome, bundlerPath, vendorPath, runtime, rubyPath, major } = await installBundler(meta, gemfileContents);
   process.env.GEM_HOME = gemHome;
-  (0, import_build_utils2.debug)(`Checking existing vendor directory at "${vendorPath}"`);
-  const vendorDir = (0, import_path2.join)(workPath, vendorPath);
-  const bundleDir = (0, import_path2.join)(workPath, "vendor", "bundle");
-  const relativeVendorDir = (0, import_path2.join)(entrypointFsDirname, vendorPath);
+  try {
+    (0, import_build_utils3.debug)("preparing Gemfile");
+    await prepareGemfile(gemfilePath, major);
+    (0, import_build_utils3.debug)('running "bundle lock"');
+    await bundleLock(bundlerPath, gemfilePath, rubyPath);
+  } catch (err) {
+    (0, import_build_utils3.debug)(
+      "failed to normalize Gemfile/lockfile before vendor check",
+      err
+    );
+  }
+  (0, import_build_utils3.debug)(`Checking existing vendor directory at "${vendorPath}"`);
+  const vendorDir = (0, import_path3.join)(workPath, vendorPath);
+  const bundleDir = (0, import_path3.join)(workPath, "vendor", "bundle");
+  const relativeVendorDir = (0, import_path3.join)(entrypointFsDirname, vendorPath);
   const hasRootVendorDir = await (0, import_fs_extra.pathExists)(vendorDir);
   const hasRelativeVendorDir = await (0, import_fs_extra.pathExists)(relativeVendorDir);
-  const hasVendorDir = hasRootVendorDir || hasRelativeVendorDir;
   if (hasRelativeVendorDir) {
     if (hasRootVendorDir) {
-      (0, import_build_utils2.debug)(
+      (0, import_build_utils3.debug)(
         "found two vendor directories, choosing the vendor directory relative to entrypoint"
       );
     } else {
-      (0, import_build_utils2.debug)("found vendor directory relative to entrypoint");
+      (0, import_build_utils3.debug)("found vendor directory relative to entrypoint");
     }
     await (0, import_fs_extra.move)(relativeVendorDir, vendorDir);
   } else if (hasRootVendorDir) {
-    (0, import_build_utils2.debug)("found vendor directory in project root");
+    (0, import_build_utils3.debug)("found vendor directory in project root");
   }
   await (0, import_fs_extra.ensureDir)(vendorDir);
-  if (!hasVendorDir) {
-    if (gemfilePath) {
-      (0, import_build_utils2.debug)(
-        "did not find a vendor directory but found a Gemfile, bundling gems..."
-      );
-      await bundleInstall(bundlerPath, bundleDir, gemfilePath, rubyPath, major);
-    }
-  } else {
-    (0, import_build_utils2.debug)('found vendor directory, skipping "bundle install"...');
-  }
+  await bundleInstall(bundlerPath, bundleDir, gemfilePath, rubyPath);
   try {
-    await (0, import_fs_extra.remove)((0, import_path2.join)(vendorDir, "cache"));
+    await (0, import_fs_extra.remove)((0, import_path3.join)(vendorDir, "cache"));
   } catch (e) {
   }
-  const originalRbPath = (0, import_path2.join)(__dirname, "..", "vc_init.rb");
+  const originalRbPath = (0, import_path3.join)(__dirname, "..", "vc_init.rb");
   const originalHandlerRbContents = await (0, import_fs_extra.readFile)(originalRbPath, "utf8");
-  (0, import_build_utils2.debug)("entrypoint is", entrypoint);
+  (0, import_build_utils3.debug)("entrypoint is", entrypoint);
   const userHandlerFilePath = entrypoint.replace(/\.rb$/, "");
   const nowHandlerRbContents = originalHandlerRbContents.replace(
     /__VC_HANDLER_FILENAME/g,
     userHandlerFilePath
   );
   const handlerRbFilename = "vc__handler__ruby";
-  const outputFiles = await (0, import_build_utils2.glob)("**", workPath);
-  outputFiles[`${handlerRbFilename}.rb`] = new import_build_utils2.FileBlob({
+  const predefinedExcludes = [
+    ".git/**",
+    ".gitignore",
+    ".vercel/**",
+    ".pnpm-store/**",
+    "**/node_modules/**",
+    "**/.next/**",
+    "**/.nuxt/**"
+  ];
+  const globOptions = {
+    cwd: workPath,
+    ignore: predefinedExcludes
+  };
+  const outputFiles = await (0, import_build_utils3.glob)("**", globOptions);
+  outputFiles[`${handlerRbFilename}.rb`] = new import_build_utils3.FileBlob({
     data: nowHandlerRbContents
   });
   if (config && (config.includeFiles || config.excludeFiles)) {
@@ -7224,7 +7647,7 @@ var build = async ({
       delete outputFiles[excludedPaths[i]];
     }
   }
-  const output = new import_build_utils2.Lambda({
+  const output = new import_build_utils3.Lambda({
     files: outputFiles,
     handler: `${handlerRbFilename}.vc__handler`,
     runtime,
@@ -7232,8 +7655,11 @@ var build = async ({
   });
   return { output };
 };
+var shouldServe = () => true;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   build,
+  shouldServe,
+  startDevServer,
   version
 });