@vercel/python 6.45.1 → 6.47.1

package/dist/index.js

@@ -48,7 +48,7 @@ var require_windows = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs13 = require("fs");
+    var fs14 = require("fs");
     function checkPathExt(path, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
@@ -73,12 +73,12 @@ var require_windows = __commonJS({
       return checkPathExt(path, options);
     }
     function isexe(path, options, cb) {
-      fs13.stat(path, function(er, stat) {
+      fs14.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, path, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs13.statSync(path), path, options);
+      return checkStat(fs14.statSync(path), path, options);
     }
   }
 });
@@ -88,14 +88,14 @@ var require_mode = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js"(exports, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs13 = require("fs");
+    var fs14 = require("fs");
     function isexe(path, options, cb) {
-      fs13.stat(path, function(er, stat) {
+      fs14.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs13.statSync(path), options);
+      return checkStat(fs14.statSync(path), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -119,7 +119,7 @@ var require_mode = __commonJS({
 // ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
 var require_isexe = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports, module2) {
-    var fs13 = require("fs");
+    var fs14 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -395,7 +395,7 @@ var require_shebang_command = __commonJS({
 var require_readShebang = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@6.0.5/node_modules/cross-spawn/lib/util/readShebang.js"(exports, module2) {
     "use strict";
-    var fs13 = require("fs");
+    var fs14 = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
@@ -408,9 +408,9 @@ var require_readShebang = __commonJS({
       }
       let fd;
       try {
-        fd = fs13.openSync(command, "r");
-        fs13.readSync(fd, buffer, 0, size, 0);
-        fs13.closeSync(fd);
+        fd = fs14.openSync(command, "r");
+        fs14.readSync(fd, buffer, 0, size, 0);
+        fs14.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -1497,11 +1497,11 @@ var require_parse = __commonJS({
     var resolveCommand = require_resolveCommand();
     var escape = require_escape();
     var readShebang = require_readShebang();
-    var semver = require_semver();
+    var semver2 = require_semver();
     var isWin3 = process.platform === "win32";
     var isExecutableRegExp = /\.(?:com|exe)$/i;
     var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
-    var supportsShellOption = niceTry(() => semver.satisfies(process.version, "^4.8.0 || ^5.7.0 || >= 6.0.0", true)) || false;
+    var supportsShellOption = niceTry(() => semver2.satisfies(process.version, "^4.8.0 || ^5.7.0 || >= 6.0.0", true)) || false;
     function detectShebang(parsed) {
       parsed.file = resolveCommand(parsed);
       const shebang = parsed.file && readShebang(parsed.file);
@@ -1895,9 +1895,9 @@ var require_pump = __commonJS({
   "../../node_modules/.pnpm/pump@3.0.4/node_modules/pump/index.js"(exports, module2) {
     var once = require_once();
     var eos = require_end_of_stream();
-    var fs13;
+    var fs14;
     try {
-      fs13 = require("fs");
+      fs14 = require("fs");
     } catch (e) {
     }
     var noop = function() {
@@ -1909,9 +1909,9 @@ var require_pump = __commonJS({
     var isFS = function(stream) {
       if (!ancient)
         return false;
-      if (!fs13)
+      if (!fs14)
         return false;
-      return (stream instanceof (fs13.ReadStream || noop) || stream instanceof (fs13.WriteStream || noop)) && isFn(stream.close);
+      return (stream instanceof (fs14.ReadStream || noop) || stream instanceof (fs14.WriteStream || noop)) && isFn(stream.close);
     };
     var isRequest = function(stream) {
       return stream.setHeader && isFn(stream.abort);
@@ -2651,7 +2651,7 @@ ${stderr}${stdout}`;
 var require_lib = __commonJS({
   "../../node_modules/.pnpm/which@3.0.0/node_modules/which/lib/index.js"(exports, module2) {
     var isexe = require_isexe();
-    var { join: join14, delimiter: delimiter2, sep: sep3, posix } = require("path");
+    var { join: join15, delimiter: delimiter2, sep: sep3, posix } = require("path");
     var isWindows = process.platform === "win32";
     var rSlash = new RegExp(`[${posix.sep}${sep3 === posix.sep ? "" : sep3}]`.replace(/(\\)/g, "\\$1"));
     var rRel = new RegExp(`^\\.${rSlash.source}`);
@@ -2680,7 +2680,7 @@ var require_lib = __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 + join14(pathPart, cmd);
+      return prefix + join15(pathPart, cmd);
     };
     var which2 = async (cmd, opt = {}) => {
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
@@ -2735,6 +2735,1156 @@ var require_lib = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/semver@6.3.1/node_modules/semver/semver.js
+var require_semver2 = __commonJS({
+  "../../node_modules/.pnpm/semver@6.3.1/node_modules/semver/semver.js"(exports, module2) {
+    exports = module2.exports = SemVer;
+    var debug13;
+    if (typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG)) {
+      debug13 = function() {
+        var args = Array.prototype.slice.call(arguments, 0);
+        args.unshift("SEMVER");
+        console.log.apply(console, args);
+      };
+    } else {
+      debug13 = function() {
+      };
+    }
+    exports.SEMVER_SPEC_VERSION = "2.0.0";
+    var MAX_LENGTH = 256;
+    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+    9007199254740991;
+    var MAX_SAFE_COMPONENT_LENGTH = 16;
+    var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
+    var re = exports.re = [];
+    var safeRe = exports.safeRe = [];
+    var src = exports.src = [];
+    var t = exports.tokens = {};
+    var R = 0;
+    function tok(n) {
+      t[n] = R++;
+    }
+    var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+    var safeRegexReplacements = [
+      ["\\s", 1],
+      ["\\d", MAX_LENGTH],
+      [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
+    ];
+    function makeSafeRe(value) {
+      for (var i2 = 0; i2 < safeRegexReplacements.length; i2++) {
+        var token = safeRegexReplacements[i2][0];
+        var max = safeRegexReplacements[i2][1];
+        value = value.split(token + "*").join(token + "{0," + max + "}").split(token + "+").join(token + "{1," + max + "}");
+      }
+      return value;
+    }
+    tok("NUMERICIDENTIFIER");
+    src[t.NUMERICIDENTIFIER] = "0|[1-9]\\d*";
+    tok("NUMERICIDENTIFIERLOOSE");
+    src[t.NUMERICIDENTIFIERLOOSE] = "\\d+";
+    tok("NONNUMERICIDENTIFIER");
+    src[t.NONNUMERICIDENTIFIER] = "\\d*[a-zA-Z-]" + LETTERDASHNUMBER + "*";
+    tok("MAINVERSION");
+    src[t.MAINVERSION] = "(" + src[t.NUMERICIDENTIFIER] + ")\\.(" + src[t.NUMERICIDENTIFIER] + ")\\.(" + src[t.NUMERICIDENTIFIER] + ")";
+    tok("MAINVERSIONLOOSE");
+    src[t.MAINVERSIONLOOSE] = "(" + src[t.NUMERICIDENTIFIERLOOSE] + ")\\.(" + src[t.NUMERICIDENTIFIERLOOSE] + ")\\.(" + src[t.NUMERICIDENTIFIERLOOSE] + ")";
+    tok("PRERELEASEIDENTIFIER");
+    src[t.PRERELEASEIDENTIFIER] = "(?:" + src[t.NUMERICIDENTIFIER] + "|" + src[t.NONNUMERICIDENTIFIER] + ")";
+    tok("PRERELEASEIDENTIFIERLOOSE");
+    src[t.PRERELEASEIDENTIFIERLOOSE] = "(?:" + src[t.NUMERICIDENTIFIERLOOSE] + "|" + src[t.NONNUMERICIDENTIFIER] + ")";
+    tok("PRERELEASE");
+    src[t.PRERELEASE] = "(?:-(" + src[t.PRERELEASEIDENTIFIER] + "(?:\\." + src[t.PRERELEASEIDENTIFIER] + ")*))";
+    tok("PRERELEASELOOSE");
+    src[t.PRERELEASELOOSE] = "(?:-?(" + src[t.PRERELEASEIDENTIFIERLOOSE] + "(?:\\." + src[t.PRERELEASEIDENTIFIERLOOSE] + ")*))";
+    tok("BUILDIDENTIFIER");
+    src[t.BUILDIDENTIFIER] = LETTERDASHNUMBER + "+";
+    tok("BUILD");
+    src[t.BUILD] = "(?:\\+(" + src[t.BUILDIDENTIFIER] + "(?:\\." + src[t.BUILDIDENTIFIER] + ")*))";
+    tok("FULL");
+    tok("FULLPLAIN");
+    src[t.FULLPLAIN] = "v?" + src[t.MAINVERSION] + src[t.PRERELEASE] + "?" + src[t.BUILD] + "?";
+    src[t.FULL] = "^" + src[t.FULLPLAIN] + "$";
+    tok("LOOSEPLAIN");
+    src[t.LOOSEPLAIN] = "[v=\\s]*" + src[t.MAINVERSIONLOOSE] + src[t.PRERELEASELOOSE] + "?" + src[t.BUILD] + "?";
+    tok("LOOSE");
+    src[t.LOOSE] = "^" + src[t.LOOSEPLAIN] + "$";
+    tok("GTLT");
+    src[t.GTLT] = "((?:<|>)?=?)";
+    tok("XRANGEIDENTIFIERLOOSE");
+    src[t.XRANGEIDENTIFIERLOOSE] = src[t.NUMERICIDENTIFIERLOOSE] + "|x|X|\\*";
+    tok("XRANGEIDENTIFIER");
+    src[t.XRANGEIDENTIFIER] = src[t.NUMERICIDENTIFIER] + "|x|X|\\*";
+    tok("XRANGEPLAIN");
+    src[t.XRANGEPLAIN] = "[v=\\s]*(" + src[t.XRANGEIDENTIFIER] + ")(?:\\.(" + src[t.XRANGEIDENTIFIER] + ")(?:\\.(" + src[t.XRANGEIDENTIFIER] + ")(?:" + src[t.PRERELEASE] + ")?" + src[t.BUILD] + "?)?)?";
+    tok("XRANGEPLAINLOOSE");
+    src[t.XRANGEPLAINLOOSE] = "[v=\\s]*(" + src[t.XRANGEIDENTIFIERLOOSE] + ")(?:\\.(" + src[t.XRANGEIDENTIFIERLOOSE] + ")(?:\\.(" + src[t.XRANGEIDENTIFIERLOOSE] + ")(?:" + src[t.PRERELEASELOOSE] + ")?" + src[t.BUILD] + "?)?)?";
+    tok("XRANGE");
+    src[t.XRANGE] = "^" + src[t.GTLT] + "\\s*" + src[t.XRANGEPLAIN] + "$";
+    tok("XRANGELOOSE");
+    src[t.XRANGELOOSE] = "^" + src[t.GTLT] + "\\s*" + src[t.XRANGEPLAINLOOSE] + "$";
+    tok("COERCE");
+    src[t.COERCE] = "(^|[^\\d])(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "})(?:\\.(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "}))?(?:\\.(\\d{1," + MAX_SAFE_COMPONENT_LENGTH + "}))?(?:$|[^\\d])";
+    tok("COERCERTL");
+    re[t.COERCERTL] = new RegExp(src[t.COERCE], "g");
+    safeRe[t.COERCERTL] = new RegExp(makeSafeRe(src[t.COERCE]), "g");
+    tok("LONETILDE");
+    src[t.LONETILDE] = "(?:~>?)";
+    tok("TILDETRIM");
+    src[t.TILDETRIM] = "(\\s*)" + src[t.LONETILDE] + "\\s+";
+    re[t.TILDETRIM] = new RegExp(src[t.TILDETRIM], "g");
+    safeRe[t.TILDETRIM] = new RegExp(makeSafeRe(src[t.TILDETRIM]), "g");
+    var tildeTrimReplace = "$1~";
+    tok("TILDE");
+    src[t.TILDE] = "^" + src[t.LONETILDE] + src[t.XRANGEPLAIN] + "$";
+    tok("TILDELOOSE");
+    src[t.TILDELOOSE] = "^" + src[t.LONETILDE] + src[t.XRANGEPLAINLOOSE] + "$";
+    tok("LONECARET");
+    src[t.LONECARET] = "(?:\\^)";
+    tok("CARETTRIM");
+    src[t.CARETTRIM] = "(\\s*)" + src[t.LONECARET] + "\\s+";
+    re[t.CARETTRIM] = new RegExp(src[t.CARETTRIM], "g");
+    safeRe[t.CARETTRIM] = new RegExp(makeSafeRe(src[t.CARETTRIM]), "g");
+    var caretTrimReplace = "$1^";
+    tok("CARET");
+    src[t.CARET] = "^" + src[t.LONECARET] + src[t.XRANGEPLAIN] + "$";
+    tok("CARETLOOSE");
+    src[t.CARETLOOSE] = "^" + src[t.LONECARET] + src[t.XRANGEPLAINLOOSE] + "$";
+    tok("COMPARATORLOOSE");
+    src[t.COMPARATORLOOSE] = "^" + src[t.GTLT] + "\\s*(" + src[t.LOOSEPLAIN] + ")$|^$";
+    tok("COMPARATOR");
+    src[t.COMPARATOR] = "^" + src[t.GTLT] + "\\s*(" + src[t.FULLPLAIN] + ")$|^$";
+    tok("COMPARATORTRIM");
+    src[t.COMPARATORTRIM] = "(\\s*)" + src[t.GTLT] + "\\s*(" + src[t.LOOSEPLAIN] + "|" + src[t.XRANGEPLAIN] + ")";
+    re[t.COMPARATORTRIM] = new RegExp(src[t.COMPARATORTRIM], "g");
+    safeRe[t.COMPARATORTRIM] = new RegExp(makeSafeRe(src[t.COMPARATORTRIM]), "g");
+    var comparatorTrimReplace = "$1$2$3";
+    tok("HYPHENRANGE");
+    src[t.HYPHENRANGE] = "^\\s*(" + src[t.XRANGEPLAIN] + ")\\s+-\\s+(" + src[t.XRANGEPLAIN] + ")\\s*$";
+    tok("HYPHENRANGELOOSE");
+    src[t.HYPHENRANGELOOSE] = "^\\s*(" + src[t.XRANGEPLAINLOOSE] + ")\\s+-\\s+(" + src[t.XRANGEPLAINLOOSE] + ")\\s*$";
+    tok("STAR");
+    src[t.STAR] = "(<|>)?=?\\s*\\*";
+    for (i = 0; i < R; i++) {
+      debug13(i, src[i]);
+      if (!re[i]) {
+        re[i] = new RegExp(src[i]);
+        safeRe[i] = new RegExp(makeSafeRe(src[i]));
+      }
+    }
+    var i;
+    exports.parse = parse2;
+    function parse2(version2, options) {
+      if (!options || typeof options !== "object") {
+        options = {
+          loose: !!options,
+          includePrerelease: false
+        };
+      }
+      if (version2 instanceof SemVer) {
+        return version2;
+      }
+      if (typeof version2 !== "string") {
+        return null;
+      }
+      if (version2.length > MAX_LENGTH) {
+        return null;
+      }
+      var r = options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL];
+      if (!r.test(version2)) {
+        return null;
+      }
+      try {
+        return new SemVer(version2, options);
+      } catch (er) {
+        return null;
+      }
+    }
+    exports.valid = valid;
+    function valid(version2, options) {
+      var v = parse2(version2, options);
+      return v ? v.version : null;
+    }
+    exports.clean = clean;
+    function clean(version2, options) {
+      var s = parse2(version2.trim().replace(/^[=v]+/, ""), options);
+      return s ? s.version : null;
+    }
+    exports.SemVer = SemVer;
+    function SemVer(version2, options) {
+      if (!options || typeof options !== "object") {
+        options = {
+          loose: !!options,
+          includePrerelease: false
+        };
+      }
+      if (version2 instanceof SemVer) {
+        if (version2.loose === options.loose) {
+          return version2;
+        } else {
+          version2 = version2.version;
+        }
+      } else if (typeof version2 !== "string") {
+        throw new TypeError("Invalid Version: " + version2);
+      }
+      if (version2.length > MAX_LENGTH) {
+        throw new TypeError("version is longer than " + MAX_LENGTH + " characters");
+      }
+      if (!(this instanceof SemVer)) {
+        return new SemVer(version2, options);
+      }
+      debug13("SemVer", version2, options);
+      this.options = options;
+      this.loose = !!options.loose;
+      var m = version2.trim().match(options.loose ? safeRe[t.LOOSE] : safeRe[t.FULL]);
+      if (!m) {
+        throw new TypeError("Invalid Version: " + version2);
+      }
+      this.raw = version2;
+      this.major = +m[1];
+      this.minor = +m[2];
+      this.patch = +m[3];
+      if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+        throw new TypeError("Invalid major version");
+      }
+      if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+        throw new TypeError("Invalid minor version");
+      }
+      if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+        throw new TypeError("Invalid patch version");
+      }
+      if (!m[4]) {
+        this.prerelease = [];
+      } else {
+        this.prerelease = m[4].split(".").map(function(id) {
+          if (/^[0-9]+$/.test(id)) {
+            var num = +id;
+            if (num >= 0 && num < MAX_SAFE_INTEGER) {
+              return num;
+            }
+          }
+          return id;
+        });
+      }
+      this.build = m[5] ? m[5].split(".") : [];
+      this.format();
+    }
+    SemVer.prototype.format = function() {
+      this.version = this.major + "." + this.minor + "." + this.patch;
+      if (this.prerelease.length) {
+        this.version += "-" + this.prerelease.join(".");
+      }
+      return this.version;
+    };
+    SemVer.prototype.toString = function() {
+      return this.version;
+    };
+    SemVer.prototype.compare = function(other) {
+      debug13("SemVer.compare", this.version, this.options, other);
+      if (!(other instanceof SemVer)) {
+        other = new SemVer(other, this.options);
+      }
+      return this.compareMain(other) || this.comparePre(other);
+    };
+    SemVer.prototype.compareMain = function(other) {
+      if (!(other instanceof SemVer)) {
+        other = new SemVer(other, this.options);
+      }
+      return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
+    };
+    SemVer.prototype.comparePre = function(other) {
+      if (!(other instanceof SemVer)) {
+        other = new SemVer(other, this.options);
+      }
+      if (this.prerelease.length && !other.prerelease.length) {
+        return -1;
+      } else if (!this.prerelease.length && other.prerelease.length) {
+        return 1;
+      } else if (!this.prerelease.length && !other.prerelease.length) {
+        return 0;
+      }
+      var i2 = 0;
+      do {
+        var a = this.prerelease[i2];
+        var b = other.prerelease[i2];
+        debug13("prerelease compare", i2, a, b);
+        if (a === void 0 && b === void 0) {
+          return 0;
+        } else if (b === void 0) {
+          return 1;
+        } else if (a === void 0) {
+          return -1;
+        } else if (a === b) {
+          continue;
+        } else {
+          return compareIdentifiers(a, b);
+        }
+      } while (++i2);
+    };
+    SemVer.prototype.compareBuild = function(other) {
+      if (!(other instanceof SemVer)) {
+        other = new SemVer(other, this.options);
+      }
+      var i2 = 0;
+      do {
+        var a = this.build[i2];
+        var b = other.build[i2];
+        debug13("prerelease compare", i2, a, b);
+        if (a === void 0 && b === void 0) {
+          return 0;
+        } else if (b === void 0) {
+          return 1;
+        } else if (a === void 0) {
+          return -1;
+        } else if (a === b) {
+          continue;
+        } else {
+          return compareIdentifiers(a, b);
+        }
+      } while (++i2);
+    };
+    SemVer.prototype.inc = function(release, identifier) {
+      switch (release) {
+        case "premajor":
+          this.prerelease.length = 0;
+          this.patch = 0;
+          this.minor = 0;
+          this.major++;
+          this.inc("pre", identifier);
+          break;
+        case "preminor":
+          this.prerelease.length = 0;
+          this.patch = 0;
+          this.minor++;
+          this.inc("pre", identifier);
+          break;
+        case "prepatch":
+          this.prerelease.length = 0;
+          this.inc("patch", identifier);
+          this.inc("pre", identifier);
+          break;
+        case "prerelease":
+          if (this.prerelease.length === 0) {
+            this.inc("patch", identifier);
+          }
+          this.inc("pre", identifier);
+          break;
+        case "major":
+          if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
+            this.major++;
+          }
+          this.minor = 0;
+          this.patch = 0;
+          this.prerelease = [];
+          break;
+        case "minor":
+          if (this.patch !== 0 || this.prerelease.length === 0) {
+            this.minor++;
+          }
+          this.patch = 0;
+          this.prerelease = [];
+          break;
+        case "patch":
+          if (this.prerelease.length === 0) {
+            this.patch++;
+          }
+          this.prerelease = [];
+          break;
+        case "pre":
+          if (this.prerelease.length === 0) {
+            this.prerelease = [0];
+          } else {
+            var i2 = this.prerelease.length;
+            while (--i2 >= 0) {
+              if (typeof this.prerelease[i2] === "number") {
+                this.prerelease[i2]++;
+                i2 = -2;
+              }
+            }
+            if (i2 === -1) {
+              this.prerelease.push(0);
+            }
+          }
+          if (identifier) {
+            if (this.prerelease[0] === identifier) {
+              if (isNaN(this.prerelease[1])) {
+                this.prerelease = [identifier, 0];
+              }
+            } else {
+              this.prerelease = [identifier, 0];
+            }
+          }
+          break;
+        default:
+          throw new Error("invalid increment argument: " + release);
+      }
+      this.format();
+      this.raw = this.version;
+      return this;
+    };
+    exports.inc = inc;
+    function inc(version2, release, loose, identifier) {
+      if (typeof loose === "string") {
+        identifier = loose;
+        loose = void 0;
+      }
+      try {
+        return new SemVer(version2, loose).inc(release, identifier).version;
+      } catch (er) {
+        return null;
+      }
+    }
+    exports.diff = diff;
+    function diff(version1, version2) {
+      if (eq(version1, version2)) {
+        return null;
+      } else {
+        var v1 = parse2(version1);
+        var v2 = parse2(version2);
+        var prefix = "";
+        if (v1.prerelease.length || v2.prerelease.length) {
+          prefix = "pre";
+          var defaultResult = "prerelease";
+        }
+        for (var key in v1) {
+          if (key === "major" || key === "minor" || key === "patch") {
+            if (v1[key] !== v2[key]) {
+              return prefix + key;
+            }
+          }
+        }
+        return defaultResult;
+      }
+    }
+    exports.compareIdentifiers = compareIdentifiers;
+    var numeric = /^[0-9]+$/;
+    function compareIdentifiers(a, b) {
+      var anum = numeric.test(a);
+      var bnum = numeric.test(b);
+      if (anum && bnum) {
+        a = +a;
+        b = +b;
+      }
+      return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+    }
+    exports.rcompareIdentifiers = rcompareIdentifiers;
+    function rcompareIdentifiers(a, b) {
+      return compareIdentifiers(b, a);
+    }
+    exports.major = major;
+    function major(a, loose) {
+      return new SemVer(a, loose).major;
+    }
+    exports.minor = minor;
+    function minor(a, loose) {
+      return new SemVer(a, loose).minor;
+    }
+    exports.patch = patch;
+    function patch(a, loose) {
+      return new SemVer(a, loose).patch;
+    }
+    exports.compare = compare;
+    function compare(a, b, loose) {
+      return new SemVer(a, loose).compare(new SemVer(b, loose));
+    }
+    exports.compareLoose = compareLoose;
+    function compareLoose(a, b) {
+      return compare(a, b, true);
+    }
+    exports.compareBuild = compareBuild;
+    function compareBuild(a, b, loose) {
+      var versionA = new SemVer(a, loose);
+      var versionB = new SemVer(b, loose);
+      return versionA.compare(versionB) || versionA.compareBuild(versionB);
+    }
+    exports.rcompare = rcompare;
+    function rcompare(a, b, loose) {
+      return compare(b, a, loose);
+    }
+    exports.sort = sort;
+    function sort(list, loose) {
+      return list.sort(function(a, b) {
+        return exports.compareBuild(a, b, loose);
+      });
+    }
+    exports.rsort = rsort;
+    function rsort(list, loose) {
+      return list.sort(function(a, b) {
+        return exports.compareBuild(b, a, loose);
+      });
+    }
+    exports.gt = gt;
+    function gt(a, b, loose) {
+      return compare(a, b, loose) > 0;
+    }
+    exports.lt = lt;
+    function lt(a, b, loose) {
+      return compare(a, b, loose) < 0;
+    }
+    exports.eq = eq;
+    function eq(a, b, loose) {
+      return compare(a, b, loose) === 0;
+    }
+    exports.neq = neq;
+    function neq(a, b, loose) {
+      return compare(a, b, loose) !== 0;
+    }
+    exports.gte = gte;
+    function gte(a, b, loose) {
+      return compare(a, b, loose) >= 0;
+    }
+    exports.lte = lte;
+    function lte(a, b, loose) {
+      return compare(a, b, loose) <= 0;
+    }
+    exports.cmp = cmp;
+    function cmp(a, op, b, loose) {
+      switch (op) {
+        case "===":
+          if (typeof a === "object")
+            a = a.version;
+          if (typeof b === "object")
+            b = b.version;
+          return a === b;
+        case "!==":
+          if (typeof a === "object")
+            a = a.version;
+          if (typeof b === "object")
+            b = b.version;
+          return a !== b;
+        case "":
+        case "=":
+        case "==":
+          return eq(a, b, loose);
+        case "!=":
+          return neq(a, b, loose);
+        case ">":
+          return gt(a, b, loose);
+        case ">=":
+          return gte(a, b, loose);
+        case "<":
+          return lt(a, b, loose);
+        case "<=":
+          return lte(a, b, loose);
+        default:
+          throw new TypeError("Invalid operator: " + op);
+      }
+    }
+    exports.Comparator = Comparator;
+    function Comparator(comp, options) {
+      if (!options || typeof options !== "object") {
+        options = {
+          loose: !!options,
+          includePrerelease: false
+        };
+      }
+      if (comp instanceof Comparator) {
+        if (comp.loose === !!options.loose) {
+          return comp;
+        } else {
+          comp = comp.value;
+        }
+      }
+      if (!(this instanceof Comparator)) {
+        return new Comparator(comp, options);
+      }
+      comp = comp.trim().split(/\s+/).join(" ");
+      debug13("comparator", comp, options);
+      this.options = options;
+      this.loose = !!options.loose;
+      this.parse(comp);
+      if (this.semver === ANY) {
+        this.value = "";
+      } else {
+        this.value = this.operator + this.semver.version;
+      }
+      debug13("comp", this);
+    }
+    var ANY = {};
+    Comparator.prototype.parse = function(comp) {
+      var r = this.options.loose ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR];
+      var m = comp.match(r);
+      if (!m) {
+        throw new TypeError("Invalid comparator: " + comp);
+      }
+      this.operator = m[1] !== void 0 ? m[1] : "";
+      if (this.operator === "=") {
+        this.operator = "";
+      }
+      if (!m[2]) {
+        this.semver = ANY;
+      } else {
+        this.semver = new SemVer(m[2], this.options.loose);
+      }
+    };
+    Comparator.prototype.toString = function() {
+      return this.value;
+    };
+    Comparator.prototype.test = function(version2) {
+      debug13("Comparator.test", version2, this.options.loose);
+      if (this.semver === ANY || version2 === ANY) {
+        return true;
+      }
+      if (typeof version2 === "string") {
+        try {
+          version2 = new SemVer(version2, this.options);
+        } catch (er) {
+          return false;
+        }
+      }
+      return cmp(version2, this.operator, this.semver, this.options);
+    };
+    Comparator.prototype.intersects = function(comp, options) {
+      if (!(comp instanceof Comparator)) {
+        throw new TypeError("a Comparator is required");
+      }
+      if (!options || typeof options !== "object") {
+        options = {
+          loose: !!options,
+          includePrerelease: false
+        };
+      }
+      var rangeTmp;
+      if (this.operator === "") {
+        if (this.value === "") {
+          return true;
+        }
+        rangeTmp = new Range(comp.value, options);
+        return satisfies(this.value, rangeTmp, options);
+      } else if (comp.operator === "") {
+        if (comp.value === "") {
+          return true;
+        }
+        rangeTmp = new Range(this.value, options);
+        return satisfies(comp.semver, rangeTmp, options);
+      }
+      var sameDirectionIncreasing = (this.operator === ">=" || this.operator === ">") && (comp.operator === ">=" || comp.operator === ">");
+      var sameDirectionDecreasing = (this.operator === "<=" || this.operator === "<") && (comp.operator === "<=" || comp.operator === "<");
+      var sameSemVer = this.semver.version === comp.semver.version;
+      var differentDirectionsInclusive = (this.operator === ">=" || this.operator === "<=") && (comp.operator === ">=" || comp.operator === "<=");
+      var oppositeDirectionsLessThan = cmp(this.semver, "<", comp.semver, options) && ((this.operator === ">=" || this.operator === ">") && (comp.operator === "<=" || comp.operator === "<"));
+      var oppositeDirectionsGreaterThan = cmp(this.semver, ">", comp.semver, options) && ((this.operator === "<=" || this.operator === "<") && (comp.operator === ">=" || comp.operator === ">"));
+      return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;
+    };
+    exports.Range = Range;
+    function Range(range, options) {
+      if (!options || typeof options !== "object") {
+        options = {
+          loose: !!options,
+          includePrerelease: false
+        };
+      }
+      if (range instanceof Range) {
+        if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
+          return range;
+        } else {
+          return new Range(range.raw, options);
+        }
+      }
+      if (range instanceof Comparator) {
+        return new Range(range.value, options);
+      }
+      if (!(this instanceof Range)) {
+        return new Range(range, options);
+      }
+      this.options = options;
+      this.loose = !!options.loose;
+      this.includePrerelease = !!options.includePrerelease;
+      this.raw = range.trim().split(/\s+/).join(" ");
+      this.set = this.raw.split("||").map(function(range2) {
+        return this.parseRange(range2.trim());
+      }, this).filter(function(c) {
+        return c.length;
+      });
+      if (!this.set.length) {
+        throw new TypeError("Invalid SemVer Range: " + this.raw);
+      }
+      this.format();
+    }
+    Range.prototype.format = function() {
+      this.range = this.set.map(function(comps) {
+        return comps.join(" ").trim();
+      }).join("||").trim();
+      return this.range;
+    };
+    Range.prototype.toString = function() {
+      return this.range;
+    };
+    Range.prototype.parseRange = function(range) {
+      var loose = this.options.loose;
+      var hr = loose ? safeRe[t.HYPHENRANGELOOSE] : safeRe[t.HYPHENRANGE];
+      range = range.replace(hr, hyphenReplace);
+      debug13("hyphen replace", range);
+      range = range.replace(safeRe[t.COMPARATORTRIM], comparatorTrimReplace);
+      debug13("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(" ");
+      var compRe = loose ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR];
+      var set = range.split(" ").map(function(comp) {
+        return parseComparator(comp, this.options);
+      }, this).join(" ").split(/\s+/);
+      if (this.options.loose) {
+        set = set.filter(function(comp) {
+          return !!comp.match(compRe);
+        });
+      }
+      set = set.map(function(comp) {
+        return new Comparator(comp, this.options);
+      }, this);
+      return set;
+    };
+    Range.prototype.intersects = function(range, options) {
+      if (!(range instanceof Range)) {
+        throw new TypeError("a Range is required");
+      }
+      return this.set.some(function(thisComparators) {
+        return isSatisfiable(thisComparators, options) && range.set.some(function(rangeComparators) {
+          return isSatisfiable(rangeComparators, options) && thisComparators.every(function(thisComparator) {
+            return rangeComparators.every(function(rangeComparator) {
+              return thisComparator.intersects(rangeComparator, options);
+            });
+          });
+        });
+      });
+    };
+    function isSatisfiable(comparators, options) {
+      var result = true;
+      var remainingComparators = comparators.slice();
+      var testComparator = remainingComparators.pop();
+      while (result && remainingComparators.length) {
+        result = remainingComparators.every(function(otherComparator) {
+          return testComparator.intersects(otherComparator, options);
+        });
+        testComparator = remainingComparators.pop();
+      }
+      return result;
+    }
+    exports.toComparators = toComparators;
+    function toComparators(range, options) {
+      return new Range(range, options).set.map(function(comp) {
+        return comp.map(function(c) {
+          return c.value;
+        }).join(" ").trim().split(" ");
+      });
+    }
+    function parseComparator(comp, options) {
+      debug13("comp", comp, options);
+      comp = replaceCarets(comp, options);
+      debug13("caret", comp);
+      comp = replaceTildes(comp, options);
+      debug13("tildes", comp);
+      comp = replaceXRanges(comp, options);
+      debug13("xrange", comp);
+      comp = replaceStars(comp, options);
+      debug13("stars", comp);
+      return comp;
+    }
+    function isX(id) {
+      return !id || id.toLowerCase() === "x" || id === "*";
+    }
+    function replaceTildes(comp, options) {
+      return comp.trim().split(/\s+/).map(function(comp2) {
+        return replaceTilde(comp2, options);
+      }).join(" ");
+    }
+    function replaceTilde(comp, options) {
+      var r = options.loose ? safeRe[t.TILDELOOSE] : safeRe[t.TILDE];
+      return comp.replace(r, function(_, M, m, p, pr) {
+        debug13("tilde", comp, _, M, m, p, pr);
+        var ret;
+        if (isX(M)) {
+          ret = "";
+        } else if (isX(m)) {
+          ret = ">=" + M + ".0.0 <" + (+M + 1) + ".0.0";
+        } else if (isX(p)) {
+          ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
+        } else if (pr) {
+          debug13("replaceTilde pr", pr);
+          ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
+        } else {
+          ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
+        }
+        debug13("tilde return", ret);
+        return ret;
+      });
+    }
+    function replaceCarets(comp, options) {
+      return comp.trim().split(/\s+/).map(function(comp2) {
+        return replaceCaret(comp2, options);
+      }).join(" ");
+    }
+    function replaceCaret(comp, options) {
+      debug13("caret", comp, options);
+      var r = options.loose ? safeRe[t.CARETLOOSE] : safeRe[t.CARET];
+      return comp.replace(r, function(_, M, m, p, pr) {
+        debug13("caret", comp, _, M, m, p, pr);
+        var ret;
+        if (isX(M)) {
+          ret = "";
+        } else if (isX(m)) {
+          ret = ">=" + M + ".0.0 <" + (+M + 1) + ".0.0";
+        } else if (isX(p)) {
+          if (M === "0") {
+            ret = ">=" + M + "." + m + ".0 <" + M + "." + (+m + 1) + ".0";
+          } else {
+            ret = ">=" + M + "." + m + ".0 <" + (+M + 1) + ".0.0";
+          }
+        } else if (pr) {
+          debug13("replaceCaret pr", pr);
+          if (M === "0") {
+            if (m === "0") {
+              ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + m + "." + (+p + 1);
+            } else {
+              ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + M + "." + (+m + 1) + ".0";
+            }
+          } else {
+            ret = ">=" + M + "." + m + "." + p + "-" + pr + " <" + (+M + 1) + ".0.0";
+          }
+        } else {
+          debug13("no pr");
+          if (M === "0") {
+            if (m === "0") {
+              ret = ">=" + M + "." + m + "." + p + " <" + M + "." + m + "." + (+p + 1);
+            } else {
+              ret = ">=" + M + "." + m + "." + p + " <" + M + "." + (+m + 1) + ".0";
+            }
+          } else {
+            ret = ">=" + M + "." + m + "." + p + " <" + (+M + 1) + ".0.0";
+          }
+        }
+        debug13("caret return", ret);
+        return ret;
+      });
+    }
+    function replaceXRanges(comp, options) {
+      debug13("replaceXRanges", comp, options);
+      return comp.split(/\s+/).map(function(comp2) {
+        return replaceXRange(comp2, options);
+      }).join(" ");
+    }
+    function replaceXRange(comp, options) {
+      comp = comp.trim();
+      var r = options.loose ? safeRe[t.XRANGELOOSE] : safeRe[t.XRANGE];
+      return comp.replace(r, function(ret, gtlt, M, m, p, pr) {
+        debug13("xRange", comp, ret, gtlt, M, m, p, pr);
+        var xM = isX(M);
+        var xm = xM || isX(m);
+        var xp = xm || isX(p);
+        var anyX = xp;
+        if (gtlt === "=" && anyX) {
+          gtlt = "";
+        }
+        pr = options.includePrerelease ? "-0" : "";
+        if (xM) {
+          if (gtlt === ">" || gtlt === "<") {
+            ret = "<0.0.0-0";
+          } else {
+            ret = "*";
+          }
+        } else if (gtlt && anyX) {
+          if (xm) {
+            m = 0;
+          }
+          p = 0;
+          if (gtlt === ">") {
+            gtlt = ">=";
+            if (xm) {
+              M = +M + 1;
+              m = 0;
+              p = 0;
+            } else {
+              m = +m + 1;
+              p = 0;
+            }
+          } else if (gtlt === "<=") {
+            gtlt = "<";
+            if (xm) {
+              M = +M + 1;
+            } else {
+              m = +m + 1;
+            }
+          }
+          ret = gtlt + M + "." + m + "." + p + pr;
+        } else if (xm) {
+          ret = ">=" + M + ".0.0" + pr + " <" + (+M + 1) + ".0.0" + pr;
+        } else if (xp) {
+          ret = ">=" + M + "." + m + ".0" + pr + " <" + M + "." + (+m + 1) + ".0" + pr;
+        }
+        debug13("xRange return", ret);
+        return ret;
+      });
+    }
+    function replaceStars(comp, options) {
+      debug13("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) {
+      if (isX(fM)) {
+        from = "";
+      } else if (isX(fm)) {
+        from = ">=" + fM + ".0.0";
+      } else if (isX(fp)) {
+        from = ">=" + fM + "." + fm + ".0";
+      } else {
+        from = ">=" + from;
+      }
+      if (isX(tM)) {
+        to = "";
+      } else if (isX(tm)) {
+        to = "<" + (+tM + 1) + ".0.0";
+      } else if (isX(tp)) {
+        to = "<" + tM + "." + (+tm + 1) + ".0";
+      } else if (tpr) {
+        to = "<=" + tM + "." + tm + "." + tp + "-" + tpr;
+      } else {
+        to = "<=" + to;
+      }
+      return (from + " " + to).trim();
+    }
+    Range.prototype.test = function(version2) {
+      if (!version2) {
+        return false;
+      }
+      if (typeof version2 === "string") {
+        try {
+          version2 = new SemVer(version2, this.options);
+        } catch (er) {
+          return false;
+        }
+      }
+      for (var i2 = 0; i2 < this.set.length; i2++) {
+        if (testSet(this.set[i2], version2, this.options)) {
+          return true;
+        }
+      }
+      return false;
+    };
+    function testSet(set, version2, options) {
+      for (var i2 = 0; i2 < set.length; i2++) {
+        if (!set[i2].test(version2)) {
+          return false;
+        }
+      }
+      if (version2.prerelease.length && !options.includePrerelease) {
+        for (i2 = 0; i2 < set.length; i2++) {
+          debug13(set[i2].semver);
+          if (set[i2].semver === ANY) {
+            continue;
+          }
+          if (set[i2].semver.prerelease.length > 0) {
+            var allowed = set[i2].semver;
+            if (allowed.major === version2.major && allowed.minor === version2.minor && allowed.patch === version2.patch) {
+              return true;
+            }
+          }
+        }
+        return false;
+      }
+      return true;
+    }
+    exports.satisfies = satisfies;
+    function satisfies(version2, range, options) {
+      try {
+        range = new Range(range, options);
+      } catch (er) {
+        return false;
+      }
+      return range.test(version2);
+    }
+    exports.maxSatisfying = maxSatisfying;
+    function maxSatisfying(versions, range, options) {
+      var max = null;
+      var maxSV = null;
+      try {
+        var rangeObj = new Range(range, options);
+      } catch (er) {
+        return null;
+      }
+      versions.forEach(function(v) {
+        if (rangeObj.test(v)) {
+          if (!max || maxSV.compare(v) === -1) {
+            max = v;
+            maxSV = new SemVer(max, options);
+          }
+        }
+      });
+      return max;
+    }
+    exports.minSatisfying = minSatisfying;
+    function minSatisfying(versions, range, options) {
+      var min = null;
+      var minSV = null;
+      try {
+        var rangeObj = new Range(range, options);
+      } catch (er) {
+        return null;
+      }
+      versions.forEach(function(v) {
+        if (rangeObj.test(v)) {
+          if (!min || minSV.compare(v) === 1) {
+            min = v;
+            minSV = new SemVer(min, options);
+          }
+        }
+      });
+      return min;
+    }
+    exports.minVersion = minVersion;
+    function minVersion(range, loose) {
+      range = new Range(range, loose);
+      var minver = new SemVer("0.0.0");
+      if (range.test(minver)) {
+        return minver;
+      }
+      minver = new SemVer("0.0.0-0");
+      if (range.test(minver)) {
+        return minver;
+      }
+      minver = null;
+      for (var i2 = 0; i2 < range.set.length; ++i2) {
+        var comparators = range.set[i2];
+        comparators.forEach(function(comparator) {
+          var compver = new SemVer(comparator.semver.version);
+          switch (comparator.operator) {
+            case ">":
+              if (compver.prerelease.length === 0) {
+                compver.patch++;
+              } else {
+                compver.prerelease.push(0);
+              }
+              compver.raw = compver.format();
+            case "":
+            case ">=":
+              if (!minver || gt(minver, compver)) {
+                minver = compver;
+              }
+              break;
+            case "<":
+            case "<=":
+              break;
+            default:
+              throw new Error("Unexpected operation: " + comparator.operator);
+          }
+        });
+      }
+      if (minver && range.test(minver)) {
+        return minver;
+      }
+      return null;
+    }
+    exports.validRange = validRange;
+    function validRange(range, options) {
+      try {
+        return new Range(range, options).range || "*";
+      } catch (er) {
+        return null;
+      }
+    }
+    exports.ltr = ltr;
+    function ltr(version2, range, options) {
+      return outside(version2, range, "<", options);
+    }
+    exports.gtr = gtr;
+    function gtr(version2, range, options) {
+      return outside(version2, range, ">", options);
+    }
+    exports.outside = outside;
+    function outside(version2, range, hilo, options) {
+      version2 = new SemVer(version2, options);
+      range = new Range(range, options);
+      var gtfn, ltefn, ltfn, comp, ecomp;
+      switch (hilo) {
+        case ">":
+          gtfn = gt;
+          ltefn = lte;
+          ltfn = lt;
+          comp = ">";
+          ecomp = ">=";
+          break;
+        case "<":
+          gtfn = lt;
+          ltefn = gte;
+          ltfn = gt;
+          comp = "<";
+          ecomp = "<=";
+          break;
+        default:
+          throw new TypeError('Must provide a hilo val of "<" or ">"');
+      }
+      if (satisfies(version2, range, options)) {
+        return false;
+      }
+      for (var i2 = 0; i2 < range.set.length; ++i2) {
+        var comparators = range.set[i2];
+        var high = null;
+        var low = null;
+        comparators.forEach(function(comparator) {
+          if (comparator.semver === ANY) {
+            comparator = new Comparator(">=0.0.0");
+          }
+          high = high || comparator;
+          low = low || comparator;
+          if (gtfn(comparator.semver, high.semver, options)) {
+            high = comparator;
+          } else if (ltfn(comparator.semver, low.semver, options)) {
+            low = comparator;
+          }
+        });
+        if (high.operator === comp || high.operator === ecomp) {
+          return false;
+        }
+        if ((!low.operator || low.operator === comp) && ltefn(version2, low.semver)) {
+          return false;
+        } else if (low.operator === ecomp && ltfn(version2, low.semver)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    exports.prerelease = prerelease;
+    function prerelease(version2, options) {
+      var parsed = parse2(version2, options);
+      return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+    }
+    exports.intersects = intersects;
+    function intersects(r1, r2, options) {
+      r1 = new Range(r1, options);
+      r2 = new Range(r2, options);
+      return r1.intersects(r2);
+    }
+    exports.coerce = coerce;
+    function coerce(version2, options) {
+      if (version2 instanceof SemVer) {
+        return version2;
+      }
+      if (typeof version2 === "number") {
+        version2 = String(version2);
+      }
+      if (typeof version2 !== "string") {
+        return null;
+      }
+      options = options || {};
+      var match = null;
+      if (!options.rtl) {
+        match = version2.match(safeRe[t.COERCE]);
+      } else {
+        var next;
+        while ((next = safeRe[t.COERCERTL].exec(version2)) && (!match || match.index + match[0].length !== version2.length)) {
+          if (!match || next.index + next[0].length !== match.index + match[0].length) {
+            match = next;
+          }
+          safeRe[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
+        }
+        safeRe[t.COERCERTL].lastIndex = -1;
+      }
+      if (match === null) {
+        return null;
+      }
+      return parse2(match[2] + "." + (match[3] || "0") + "." + (match[4] || "0"), options);
+    }
+  }
+});
+
 // ../../node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/process.js
 var require_process = __commonJS({
   "../../node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/process.js"(exports, module2) {
@@ -2762,27 +3912,27 @@ var require_process = __commonJS({
 var require_filesystem = __commonJS({
   "../../node_modules/.pnpm/detect-libc@2.1.2/node_modules/detect-libc/lib/filesystem.js"(exports, module2) {
     "use strict";
-    var fs13 = require("fs");
+    var fs14 = require("fs");
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
     var readFileSync2 = (path) => {
-      const fd = fs13.openSync(path, "r");
+      const fd = fs14.openSync(path, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
-      const bytesRead = fs13.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-      fs13.close(fd, () => {
+      const bytesRead = fs14.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+      fs14.close(fd, () => {
       });
       return buffer.subarray(0, bytesRead);
     };
     var readFile2 = (path) => new Promise((resolve3, reject) => {
-      fs13.open(path, "r", (err, fd) => {
+      fs14.open(path, "r", (err, fd) => {
         if (err) {
           reject(err);
         } else {
           const buffer = Buffer.alloc(MAX_LENGTH);
-          fs13.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+          fs14.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
             resolve3(buffer.subarray(0, bytesRead));
-            fs13.close(fd, () => {
+            fs14.close(fd, () => {
             });
           });
         }
@@ -3226,16 +4376,15 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 var import_assert = __toESM(require("assert"));
-var import_child_process3 = require("child_process");
-var import_fs14 = __toESM(require("fs"));
-var import_path14 = require("path");
+var import_fs15 = __toESM(require("fs"));
+var import_path15 = require("path");
 
 // src/package-versions.ts
-var VERCEL_RUNTIME_VERSION = "0.14.2";
-var VERCEL_WORKERS_VERSION = "0.0.24";
+var VERCEL_RUNTIME_VERSION = "0.15.0";
+var VERCEL_WORKERS_VERSION = "0.0.25";
 
 // src/index.ts
-var import_build_utils18 = require("@vercel/build-utils");
+var import_build_utils19 = require("@vercel/build-utils");
 
 // src/install.ts
 var import_execa3 = __toESM(require_execa());
@@ -3261,8 +4410,10 @@ var import_execa = __toESM(require_execa());
 var import_fs = __toESM(require("fs"));
 var import_os = __toESM(require("os"));
 var import_which = __toESM(require_lib());
+var import_semver = __toESM(require_semver2());
 var import_build_utils = require("@vercel/build-utils");
 var UV_VERSION = "0.10.11";
+var MIN_UV_VERSION = "0.9.25";
 var UV_PYTHON_PATH_PREFIX = "/uv/python/";
 var UV_PYTHON_DOWNLOADS_MODE = "automatic";
 var UV_CACHE_DIR_SUBPATH = [".vercel", "python", "cache", "uv"];
@@ -3516,7 +4667,39 @@ async function findUvBinary(pythonPath) {
   } catch (err) {
     (0, import_build_utils.debug)("Failed to resolve uv fallback paths", err);
   }
-  return null;
+  return null;
+}
+function checkUvBinaryVersion(uvPath) {
+  let output;
+  try {
+    output = (0, import_child_process.execFileSync)(uvPath, ["--version"], {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      shell: isWin
+    }).trim();
+  } catch (err) {
+    throw new import_build_utils.NowBuildError({
+      code: "UV_ERROR",
+      link: "https://vercel.link/python-version",
+      message: `Found uv at "${uvPath}" but could not run "uv --version": ${err instanceof Error ? err.message : String(err)}`
+    });
+  }
+  const found = import_semver.default.coerce(output);
+  if (!found) {
+    throw new import_build_utils.NowBuildError({
+      code: "UV_ERROR",
+      link: "https://vercel.link/python-version",
+      message: `Could not determine the uv version from "${output}".`
+    });
+  }
+  if (import_semver.default.lt(found, MIN_UV_VERSION)) {
+    throw new import_build_utils.NowBuildError({
+      code: "UV_VERSION_TOO_OLD",
+      link: "https://vercel.link/python-version",
+      message: `Found uv ${found.version} at "${uvPath}", but Vercel requires uv ${MIN_UV_VERSION} or newer. Please upgrade uv: https://docs.astral.sh/uv/getting-started/installation/`
+    });
+  }
+  return output;
 }
 async function getUvBinaryOrInstall(pythonPath) {
   const uvBin = await findUvBinary(pythonPath);
@@ -4466,30 +5649,31 @@ var import_execa4 = __toESM(require_execa());
 var import_build_utils6 = require("@vercel/build-utils");
 var import_fs5 = __toESM(require("fs"));
 var import_path6 = require("path");
+
+// src/large-functions.ts
+function isLargeFunctionsEnabled() {
+  const value = process.env.VERCEL_SUPPORT_LARGE_FUNCTIONS;
+  return value === "1" || value === "true";
+}
+
+// src/compileall.ts
 function isCompileAllEnabled() {
+  if (!isLargeFunctionsEnabled())
+    return false;
   const val = process.env.VERCEL_PYTHON_COMPILEALL;
-  if (val !== void 0 && val !== "") {
-    const lower = val.toLowerCase();
-    return lower === "1" || lower === "true";
-  }
-  const hive = process.env.VERCEL_PYTHON_ON_HIVE;
-  if (hive === "1" || hive === "true") {
-    return true;
-  }
-  return false;
+  if (val === void 0 || val === "")
+    return false;
+  const lower = val.toLowerCase();
+  return lower === "1" || lower === "true";
 }
 function shouldUseCompileAll({
   isDev,
-  hasCustomCommand
+  hasCustomCommand,
+  hasCustomBuildCommand
 }) {
   if (isDev)
     return false;
-  const val = process.env.VERCEL_PYTHON_COMPILEALL;
-  if (val !== void 0 && val !== "") {
-    const lower = val.toLowerCase();
-    return lower === "1" || lower === "true";
-  }
-  if (hasCustomCommand)
+  if (hasCustomCommand || hasCustomBuildCommand)
     return false;
   return isCompileAllEnabled();
 }
@@ -4609,11 +5793,9 @@ function shouldStripVendorFile(filePath) {
     return true;
   return false;
 }
-var LAMBDA_BASE_SIZE_THRESHOLD_BYTES = 245 * 1024 * 1024;
-var OTEL_LAYER_RESERVATION_BYTES = 5 * 1024 * 1024;
-var LAMBDA_SIZE_THRESHOLD_BYTES = process.env.VERCEL_DEPLOYMENT_HAS_OTEL_LAYER === "1" ? LAMBDA_BASE_SIZE_THRESHOLD_BYTES - OTEL_LAYER_RESERVATION_BYTES : LAMBDA_BASE_SIZE_THRESHOLD_BYTES;
+var LAMBDA_SIZE_THRESHOLD_BYTES = 225 * 1024 * 1024;
 var LAMBDA_EPHEMERAL_STORAGE_BYTES = 500 * 1024 * 1024;
-var HIVE_LAMBDA_SIZE_BYTES = 1 * 1024 * 1024 * 1024;
+var MAX_LARGE_FUNCTION_UNCOMPRESSED_SIZE = 5 * 1024 * 1024 * 1024;
 var BUNDLING_DOCS_LINK = "https://vercel.com/docs/functions/runtimes/python#controlling-what-gets-bundled";
 var PythonDependencyExternalizer = class {
   constructor(options) {
@@ -4639,20 +5821,20 @@ var PythonDependencyExternalizer = class {
     if (this.hasCustomCommand) {
       return false;
     }
-    const pythonOnHiveEnabled = process.env.VERCEL_PYTHON_ON_HIVE === "1" || process.env.VERCEL_PYTHON_ON_HIVE === "true";
-    if (pythonOnHiveEnabled) {
+    if (this.totalBundleSize <= LAMBDA_SIZE_THRESHOLD_BYTES || this.uvLockPath === null) {
       return false;
-    } else if (this.totalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES && this.uvLockPath !== null) {
-      return true;
     }
-    return false;
+    if (isLargeFunctionsEnabled() && this.totalBundleSize > LAMBDA_EPHEMERAL_STORAGE_BYTES) {
+      return false;
+    }
+    return true;
   }
   /**
    * Analyze the bundle: mirror all vendor files, calculate total size,
    * and determine whether runtime installation is needed.
    * Must be called before generateBundle().
    */
-  async analyze(files) {
+  async analyze(files, options = {}) {
     this.sitePackageDirs = await getVenvSitePackagesDirs(this.venvPath);
     this.distributions = /* @__PURE__ */ new Map();
     for (const dir of this.sitePackageDirs) {
@@ -4675,25 +5857,28 @@ var PythonDependencyExternalizer = class {
     const totalBundleSizeMB = (this.totalBundleSize / (1024 * 1024)).toFixed(2);
     (0, import_build_utils7.debug)(`Total bundle size: ${totalBundleSizeMB} MB`);
     const runtimeInstallEnabled = this.shouldEnableRuntimeInstall();
-    const pythonOnHiveEnabled = process.env.VERCEL_PYTHON_ON_HIVE === "1" || process.env.VERCEL_PYTHON_ON_HIVE === "true";
-    if (this.totalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES && this.hasCustomCommand && !pythonOnHiveEnabled) {
+    const largeFunctionsEnabled = isLargeFunctionsEnabled();
+    options.onSized?.({
+      totalSizeBytes: this.totalBundleSize,
+      runtimeInstallEnabled
+    });
+    if (this.totalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES && this.hasCustomCommand && !largeFunctionsEnabled) {
       const limitMB = (LAMBDA_SIZE_THRESHOLD_BYTES / (1024 * 1024)).toFixed(0);
       throw new import_build_utils7.NowBuildError({
         code: "LAMBDA_SIZE_EXCEEDED",
-        message: `Total bundle size (${totalBundleSizeMB} MB) exceeds the size limit (${limitMB} MB).
+        message: `Total bundle size (${totalBundleSizeMB} MB) exceeds the maximum function size (${limitMB} MB).
 
-When using a custom install command, Vercel cannot automatically
-optimize dependency bundling. To reduce the size of your
-dependencies, you can:
-  1. Remove unused dependencies from your project.
-  2. Remove the custom install command to allow Vercel to manage
-     and optimize dependencies automatically.`,
+A custom install command prevents Vercel from optimizing your
+function bundle size automatically. To fix this, you can:
+  1. Remove unused dependencies from your project, or
+  2. Remove the custom install command so Vercel can optimize
+     the function bundle automatically.`,
         link: BUNDLING_DOCS_LINK,
         action: "Learn More"
       });
     }
-    if (pythonOnHiveEnabled && this.totalBundleSize > HIVE_LAMBDA_SIZE_BYTES) {
-      const limitMB = (HIVE_LAMBDA_SIZE_BYTES / (1024 * 1024)).toFixed(0);
+    if (largeFunctionsEnabled && this.totalBundleSize >= MAX_LARGE_FUNCTION_UNCOMPRESSED_SIZE) {
+      const limitMB = (MAX_LARGE_FUNCTION_UNCOMPRESSED_SIZE / (1024 * 1024)).toFixed(0);
       throw new import_build_utils7.NowBuildError({
         code: "LAMBDA_SIZE_EXCEEDED",
         message: `Total bundle size (${totalBundleSizeMB} MB) exceeds the extended function size limit (${limitMB} MB).
@@ -4715,6 +5900,10 @@ application into smaller functions.`,
    * Mutates `files` in place: adds vendor files (private + knapsack-selected
    * public), runtime config, and uv binary.
    * Must be called after analyze().
+   *
+   * If large functions are allowed and the bundle can't fit AWS Lambda, falls
+   * back to bundling everything for Hive and returns `fellBackToFullBundle:
+   * true` so the caller can apply the same compileall handling.
    */
   async generateBundle(files) {
     if (!this.analyzed) {
@@ -4723,54 +5912,49 @@ application into smaller functions.`,
       );
     }
     if (!this.uvLockPath || !this.uvProjectDir) {
-      throw new import_build_utils7.NowBuildError({
-        code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
-        message: "Runtime dependency installation requires a uv.lock file and project directory."
-      });
+      throw new Error(
+        "generateBundle() requires uvLockPath and uvProjectDir to be set"
+      );
     }
     const totalBundleSizeMB = (this.totalBundleSize / (1024 * 1024)).toFixed(2);
-    console.log(
-      `Bundle size (${totalBundleSizeMB} MB) exceeds limit. Enabling runtime dependency installation.`
-    );
+    const largeFunctionsEnabled = isLargeFunctionsEnabled();
     if (this.totalBundleSize > LAMBDA_EPHEMERAL_STORAGE_BYTES) {
-      const ephemeralLimitMB = (LAMBDA_EPHEMERAL_STORAGE_BYTES / (1024 * 1024)).toFixed(0);
+      if (largeFunctionsEnabled) {
+        return this.bundleAllForHive(files);
+      }
+      const limitMB = (LAMBDA_EPHEMERAL_STORAGE_BYTES / (1024 * 1024)).toFixed(
+        0
+      );
       throw new import_build_utils7.NowBuildError({
         code: "LAMBDA_SIZE_EXCEEDED",
-        message: `Total bundle size (${totalBundleSizeMB} MB) exceeds Lambda ephemeral storage limit (${ephemeralLimitMB} MB).
+        message: `Total bundle size (${totalBundleSizeMB} MB) exceeds the maximum function size (${limitMB} MB).
 
-Even with runtime dependency installation, all packages must fit
-within the ${ephemeralLimitMB} MB ephemeral storage available to Lambda
-functions. Consider removing unused dependencies or splitting
-your application into smaller functions.`,
+Reduce the size of your dependencies or split your application into
+smaller functions.`,
         link: BUNDLING_DOCS_LINK,
         action: "Learn More"
       });
     }
+    const relLockPath = (0, import_path7.relative)(this.workPath, this.uvLockPath);
     let lockContent;
     try {
       lockContent = await readFile(this.uvLockPath, "utf8");
     } catch (error) {
-      if (error instanceof Error) {
-        console.log(
-          `Failed to read uv.lock file at "${this.uvLockPath}": ${error.message}`
-        );
-      } else {
-        console.log(
-          `Failed to read uv.lock file at "${this.uvLockPath}": ${String(error)}`
-        );
-      }
+      (0, import_build_utils7.debug)(
+        `Failed to read uv.lock at ${this.uvLockPath}: ${error instanceof Error ? error.message : String(error)}`
+      );
       throw new import_build_utils7.NowBuildError({
         code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
-        message: `Failed to read uv.lock file at "${this.uvLockPath}"`
+        message: `Failed to read the uv.lock file at "${relLockPath}".`
       });
     }
     let lockFile;
     try {
-      lockFile = (0, import_python_analysis3.parseUvLock)(lockContent, this.uvLockPath);
+      lockFile = (0, import_python_analysis3.parseUvLock)(lockContent, relLockPath);
     } catch (error) {
       if (error instanceof import_python_analysis3.PythonAnalysisError) {
         if (error.fileContent) {
-          console.log(
+          (0, import_build_utils7.debug)(
             `Failed to parse "${error.path}". File content:
 ${error.fileContent}`
           );
@@ -4812,19 +5996,18 @@ ${error.fileContent}`
       (name) => !forceBundledSet.has((0, import_python_analysis3.normalizePackageName)(name))
     );
     if (externalizablePublic.length === 0) {
+      if (largeFunctionsEnabled) {
+        return this.bundleAllForHive(files);
+      }
       throw new import_build_utils7.NowBuildError({
         code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
-        message: `Bundle size exceeds the Lambda limit and requires runtime
-dependency installation, but no public packages have compatible
-pre-built wheels for the Lambda platform.
-
-Runtime dependency installation requires packages to have binary
-wheels.
+        message: `Total bundle size (${totalBundleSizeMB} MB) exceeds the maximum function size and
+can't be optimized automatically because some dependencies don't
+provide a compatible pre-built wheel.
 
 To fix this, either:
   1. Regenerate your lock file with: uv lock --upgrade, or
-  2. Switch the problematic packages to ones that have pre-built
-     wheels available.`
+  2. Replace the packages that don't provide a pre-built wheel.`
       });
     }
     const packageSizes = await this.calculatePerPackageSizes();
@@ -4869,6 +6052,12 @@ To fix this, either:
     (0, import_build_utils7.debug)(
       `Fixed overhead: ${(fixedOverhead / (1024 * 1024)).toFixed(2)} MB, runtime tooling: ${(runtimeToolingOverhead / (1024 * 1024)).toFixed(2)} MB, remaining capacity for public packages: ${(remainingCapacity / (1024 * 1024)).toFixed(2)} MB`
     );
+    if (largeFunctionsEnabled && remainingCapacity < 0) {
+      return this.bundleAllForHive(files);
+    }
+    console.log(
+      `Bundle size (${totalBundleSizeMB} MB) exceeds the standard size; optimizing dependencies.`
+    );
     const externalizableSet = new Set(
       externalizablePublic.map(import_python_analysis3.normalizePackageName)
     );
@@ -4922,27 +6111,54 @@ To fix this, either:
       });
       (0, import_build_utils7.debug)(`Bundled uv binary from ${uvBinaryPath} to ${uvLocalPath}`);
     } catch (err) {
+      (0, import_build_utils7.debug)(
+        `Failed to bundle uv binary: ${err instanceof Error ? err.message : String(err)}`
+      );
       throw new import_build_utils7.NowBuildError({
         code: "RUNTIME_DEPENDENCY_INSTALLATION_FAILED",
-        message: `Failed to bundle uv binary for runtime installation: ${err instanceof Error ? err.message : String(err)}`
+        message: "Failed to prepare dependency tooling."
       });
     }
     const finalBundleSize = await calculateBundleSize(files);
     if (finalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES + 100 * 1024) {
+      if (largeFunctionsEnabled) {
+        return this.bundleAllForHive(files);
+      }
       const finalSizeMB = (finalBundleSize / (1024 * 1024)).toFixed(2);
       const limitMB = (LAMBDA_SIZE_THRESHOLD_BYTES / (1024 * 1024)).toFixed(0);
       throw new import_build_utils7.NowBuildError({
         code: "LAMBDA_SIZE_EXCEEDED",
-        message: `Total bundle size (${finalSizeMB} MB) exceeds Lambda limit (${limitMB} MB) even after
-deferring public packages to runtime installation.
+        message: `Total bundle size (${finalSizeMB} MB) exceeds the maximum function size (${limitMB} MB) even after
+optimizing dependencies.
 
-This usually means your private packages or source code are too
-large. Consider reducing the size of private dependencies or
-splitting your application.`,
+This usually means your source code or private packages are too
+large. Reduce their size or split your application into smaller
+functions.`,
         link: BUNDLING_DOCS_LINK,
         action: "Learn More"
       });
     }
+    return { fellBackToFullBundle: false };
+  }
+  /**
+   * Discard any runtime-install artifacts added so far and bundle every
+   * dependency directly, for a function that will run on Hive. Returns the
+   * fell-back signal so the caller can apply the same compileall handling.
+   */
+  bundleAllForHive(files) {
+    for (const key of [
+      `${UV_BUNDLE_DIR}/_runtime_config.json`,
+      `${UV_BUNDLE_DIR}/uv`,
+      `${UV_BUNDLE_DIR}/pyproject.toml`,
+      `${UV_BUNDLE_DIR}/uv.lock`
+    ]) {
+      delete files[key];
+    }
+    for (const [p, f] of Object.entries(this.allVendorFiles)) {
+      files[p] = f;
+    }
+    (0, import_build_utils7.debug)("Bundling all dependencies for the large functions path.");
+    return { fellBackToFullBundle: true };
   }
   /**
    * Identify public packages that have no compatible wheel for the Lambda platform.
@@ -6603,6 +7819,9 @@ var startDevServer = async (opts) => {
   try {
     const { pythonPath: systemPython } = getDefaultPythonVersion(meta);
     const uvPath = await findUvBinary(systemPython);
+    if (uvPath) {
+      checkUvBinaryVersion(uvPath);
+    }
     const venv = isInVirtualEnv();
     const serviceCount = meta.serviceCount ?? 0;
     const pythonServiceCount = meta.pythonServiceCount ?? 1;
@@ -7360,7 +8579,177 @@ async function runDjangoCollectStatic(venvPath, workPath, env, outputStaticDir,
 
 // src/index.ts
 var import_python_analysis9 = require("@vercel/python-analysis");
-var writeFile = import_fs14.default.promises.writeFile;
+
+// src/subscribers.ts
+var import_path14 = require("path");
+var import_fs14 = __toESM(require("fs"));
+var import_build_utils18 = require("@vercel/build-utils");
+var SUBSCRIBER_NAME_RE = /^[A-Za-z]([A-Za-z0-9_-]*[A-Za-z0-9])?$/;
+var MODULE_ATTR_RE = /^([A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)*):([A-Za-z_][\w]*)$/;
+var TRIGGER_NUMBER_FIELDS = [
+  {
+    field: "max_deliveries",
+    output: "maxDeliveries",
+    isValid: (value) => Number.isInteger(value) && value >= 1,
+    expected: "an integer greater than or equal to 1"
+  },
+  {
+    field: "retry_after_seconds",
+    output: "retryAfterSeconds",
+    isValid: (value) => value > 0,
+    expected: "greater than 0"
+  },
+  {
+    field: "initial_delay_seconds",
+    output: "initialDelaySeconds",
+    isValid: (value) => value >= 0,
+    expected: "greater than or equal to 0"
+  },
+  {
+    field: "max_concurrency",
+    output: "maxConcurrency",
+    isValid: (value) => Number.isInteger(value) && value >= 1,
+    expected: "an integer greater than or equal to 1"
+  }
+];
+var SUBSCRIBER_FIELD_NAMES = /* @__PURE__ */ new Set([
+  "entrypoint",
+  "topics",
+  ...TRIGGER_NUMBER_FIELDS.map(({ field }) => field)
+]);
+function safePathSegment(value) {
+  return [...value].map((char) => {
+    if (char === "_") {
+      return "__";
+    }
+    return /[A-Za-z0-9-]/.test(char) ? char : `_${char.charCodeAt(0).toString(16).toUpperCase().padStart(2, "0")}`;
+  }).join("");
+}
+async function getPyprojectSubscribers(workPath) {
+  const pyprojectPath = (0, import_path14.join)(workPath, "pyproject.toml");
+  if (!import_fs14.default.existsSync(pyprojectPath)) {
+    return [];
+  }
+  const pyproject = await (0, import_build_utils18.readConfigFile)(pyprojectPath);
+  const subscribers = pyproject?.tool?.vercel?.subscribers;
+  if (!subscribers) {
+    return [];
+  }
+  if (typeof subscribers !== "object" || Array.isArray(subscribers)) {
+    throw subscriberError('"tool.vercel.subscribers" must be an object');
+  }
+  return Promise.all(
+    Object.entries(subscribers).map(
+      ([name, config]) => parseSubscriber(workPath, name, config)
+    )
+  );
+}
+async function parseSubscriber(workPath, name, config) {
+  if (!SUBSCRIBER_NAME_RE.test(name)) {
+    throw subscriberError(
+      `subscriber name "${name}" is invalid. Names must start with a letter, end with an alphanumeric character, and contain only alphanumeric characters, hyphens, and underscores`
+    );
+  }
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw subscriberError(`subscriber "${name}" must be an object`);
+  }
+  for (const key of Object.keys(config)) {
+    if (!SUBSCRIBER_FIELD_NAMES.has(key)) {
+      throw subscriberError(
+        `subscriber "${name}" has unrecognized field "${key}"`
+      );
+    }
+  }
+  if (typeof config.entrypoint !== "string") {
+    throw subscriberError(
+      `subscriber "${name}" must define string field "entrypoint"`
+    );
+  }
+  const entrypoint = parseEntrypoint(name, config.entrypoint);
+  const existingEntrypoint = await resolveExistingEntrypoint(
+    workPath,
+    entrypoint.filePath
+  );
+  if (!existingEntrypoint) {
+    throw subscriberError(
+      `subscriber "${name}" has entrypoint "${config.entrypoint}" but file "${entrypoint.filePath}" does not exist`
+    );
+  }
+  return {
+    name,
+    entrypoint: existingEntrypoint,
+    moduleName: entrypoint.moduleName,
+    variableName: entrypoint.variableName,
+    topics: parseTopics(name, config.topics),
+    triggerDefaults: parseTriggerDefaults(name, config)
+  };
+}
+function parseEntrypoint(name, value) {
+  const match = MODULE_ATTR_RE.exec(value);
+  if (!match) {
+    throw subscriberError(
+      `subscriber "${name}" has invalid entrypoint "${value}". Use "module:object"`
+    );
+  }
+  return {
+    moduleName: match[1],
+    variableName: match[2],
+    filePath: `${match[1].replace(/\./g, "/")}.py`
+  };
+}
+async function resolveExistingEntrypoint(workPath, filePath) {
+  const candidates = [filePath, filePath.replace(/\.py$/i, "/__init__.py")];
+  for (const candidate of candidates) {
+    try {
+      const stat = await import_fs14.default.promises.stat((0, import_path14.join)(workPath, candidate));
+      if (stat.isFile()) {
+        return candidate;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function parseTopics(name, value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw subscriberError(
+      `subscriber "${name}" must define non-empty array field "topics"`
+    );
+  }
+  for (const topic of value) {
+    if (typeof topic !== "string" || topic.length === 0) {
+      throw subscriberError(
+        `subscriber "${name}" field "topics" must contain only non-empty strings`
+      );
+    }
+  }
+  return value;
+}
+function parseTriggerDefaults(subscriber, config) {
+  const defaults = {};
+  for (const { field, output, isValid, expected } of TRIGGER_NUMBER_FIELDS) {
+    const value = config[field];
+    if (value === void 0) {
+      continue;
+    }
+    if (typeof value !== "number" || !isValid(value)) {
+      throw subscriberError(
+        `subscriber "${subscriber}" field "${field}" must be ${expected}`
+      );
+    }
+    defaults[output] = value;
+  }
+  return defaults;
+}
+function subscriberError(message) {
+  return new import_build_utils18.NowBuildError({
+    code: "PYTHON_INVALID_SUBSCRIBER_CONFIG",
+    message
+  });
+}
+
+// src/index.ts
+var writeFile = import_fs15.default.promises.writeFile;
 var PYTHON_ENTRYPOINT_DOCS_URL2 = "https://vercel.com/docs/functions/runtimes/python#python-entrypoints";
 var version = -1;
 function addFiles(target, source) {
@@ -7424,7 +8813,7 @@ var frameworkHooks = {
     detected
   }) => {
     if (detected?.baseDir === void 0) {
-      (0, import_build_utils18.debug)("Django hook: no manage.py detected, skipping");
+      (0, import_build_utils19.debug)("Django hook: no manage.py detected, skipping");
       return;
     }
     let settingsResult;
@@ -7438,13 +8827,13 @@ Hint: activate a venv or run with \`uv run vercel dev\``;
       } else {
         detail = err?.stderr || err?.message || String(err);
       }
-      throw new import_build_utils18.NowBuildError({
+      throw new import_build_utils19.NowBuildError({
         code: "DJANGO_SETTINGS_FAILED",
         message: `Failed to read Django application settings from ${projectDir}/manage.py:
 ${detail}`
       });
     }
-    (0, import_build_utils18.debug)(`Django settings: ${JSON.stringify(settingsResult)}`);
+    (0, import_build_utils19.debug)(`Django settings: ${JSON.stringify(settingsResult)}`);
     const { djangoSettings, settingsModule, djangoVersion } = settingsResult;
     if (djangoVersion) {
       console.log(`Django ${djangoVersion.join(".")} detected`);
@@ -7457,7 +8846,7 @@ ${detail}`
       const variableName = parts.at(-1);
       const rel = `${parts.slice(0, -1).join("/")}.py`;
       const ep = baseDir ? `${baseDir}/${rel}` : rel;
-      (0, import_build_utils18.debug)(`Django hook: ASGI entrypoint: ${ep} (variable: ${variableName})`);
+      (0, import_build_utils19.debug)(`Django hook: ASGI entrypoint: ${ep} (variable: ${variableName})`);
       resolvedEntrypoint = { entrypoint: ep, variableName };
     } else {
       const wsgiApp = djangoSettings["WSGI_APPLICATION"];
@@ -7466,7 +8855,7 @@ ${detail}`
         const variableName = parts.at(-1);
         const rel = `${parts.slice(0, -1).join("/")}.py`;
         const ep = baseDir ? `${baseDir}/${rel}` : rel;
-        (0, import_build_utils18.debug)(
+        (0, import_build_utils19.debug)(
           `Django hook: WSGI entrypoint: ${ep} (variable: ${variableName})`
         );
         resolvedEntrypoint = { entrypoint: ep, variableName };
@@ -7474,7 +8863,7 @@ ${detail}`
     }
     let djangoStatic = null;
     if (workPath && venvPath) {
-      const outputStaticDir = (0, import_path14.join)(workPath, ".vercel", "output", "static");
+      const outputStaticDir = (0, import_path15.join)(workPath, ".vercel", "output", "static");
       djangoStatic = await runDjangoCollectStatic(
         venvPath,
         workPath,
@@ -7488,29 +8877,78 @@ ${detail}`
     return { entrypoint: resolvedEntrypoint, djangoStatic };
   }
 };
+function createRuntimeTrampoline({
+  moduleName,
+  entrypoint,
+  vendorDir,
+  variableName,
+  extraEnv = []
+}) {
+  const extraEnvLines = extraEnv.map((line) => `,
+  ${line}`).join("");
+  return `
+import importlib
+import os
+import os.path
+import site
+import sys
+
+_here = os.path.dirname(__file__)
+
+os.environ.update({
+  "__VC_HANDLER_MODULE_NAME": "${moduleName}",
+  "__VC_HANDLER_ENTRYPOINT": "${entrypoint}",
+  "__VC_HANDLER_ENTRYPOINT_ABS": os.path.join(_here, "${entrypoint}"),
+  "__VC_HANDLER_VENDOR_DIR": "${vendorDir}",
+  "__VC_HANDLER_VARIABLE_NAME": "${variableName}"${extraEnvLines}
+})
+
+_vendor_rel = '${vendorDir}'
+_vendor = os.path.normpath(os.path.join(_here, _vendor_rel))
+
+if os.path.isdir(_vendor):
+    # Process .pth files like a real site-packages dir
+    site.addsitedir(_vendor)
+
+    # Move _vendor to the front (after script dir if present)
+    try:
+        while _vendor in sys.path:
+            sys.path.remove(_vendor)
+    except ValueError:
+        pass
+
+    # Put vendored deps ahead of site-packages but after the script dir
+    idx = 1 if (sys.path and sys.path[0] in ('', _here)) else 0
+    sys.path.insert(idx, _vendor)
+
+    importlib.invalidate_caches()
+
+from vercel_runtime.vc_init import vc_handler
+`;
+}
 async function downloadFilesInWorkPath({
   entrypoint,
   workPath,
   files,
   meta = {}
 }) {
-  (0, import_build_utils18.debug)("Downloading user files...");
-  let downloadedFiles = await (0, import_build_utils18.download)(files, workPath, meta);
+  (0, import_build_utils19.debug)("Downloading user files...");
+  let downloadedFiles = await (0, import_build_utils19.download)(files, workPath, meta);
   if (meta.isDev && entrypoint) {
     const normalizedEntrypoint = entrypoint.endsWith(".py") ? entrypoint : `${entrypoint}.py`;
     if (!hasProp(downloadedFiles, entrypoint) && !hasProp(downloadedFiles, normalizedEntrypoint)) {
-      throw new import_build_utils18.NowBuildError({
+      throw new import_build_utils19.NowBuildError({
         code: "PYTHON_ENTRYPOINT_NOT_FOUND",
         message: `Configured Python entrypoint "${normalizedEntrypoint}" was not found.`,
         link: PYTHON_ENTRYPOINT_DOCS_URL2,
         action: "Learn More"
       });
     }
-    const { devCacheDir = (0, import_path14.join)(workPath, ".now", "cache") } = meta;
-    const cacheKey = (0, import_path14.basename)(entrypoint).replace(/\./g, "_");
-    const destCache = (0, import_path14.join)(devCacheDir, cacheKey);
-    await (0, import_build_utils18.download)(downloadedFiles, destCache);
-    downloadedFiles = await (0, import_build_utils18.glob)("**", destCache);
+    const { devCacheDir = (0, import_path15.join)(workPath, ".now", "cache") } = meta;
+    const cacheKey = (0, import_path15.basename)(entrypoint).replace(/\./g, "_");
+    const destCache = (0, import_path15.join)(devCacheDir, cacheKey);
+    await (0, import_build_utils19.download)(downloadedFiles, destCache);
+    downloadedFiles = await (0, import_build_utils19.glob)("**", destCache);
     workPath = destCache;
   }
   return workPath;
@@ -7543,11 +8981,11 @@ async function installInjectedPackage({
   projectDir,
   pipPlatformArgs
 }) {
-  const localDir = (0, import_path14.join)(__dirname, "..", "..", "..", "python", name);
-  const isLocalDev = import_fs14.default.existsSync((0, import_path14.join)(localDir, "pyproject.toml"));
+  const localDir = (0, import_path15.join)(__dirname, "..", "..", "..", "python", name);
+  const isLocalDev = import_fs15.default.existsSync((0, import_path15.join)(localDir, "pyproject.toml"));
   const dep = envOverride || (isLocalDev ? localDir : pinned);
   const noExclude = ["--exclude-newer-package", `${name}=false`];
-  (0, import_build_utils18.debug)(`Installing ${dep}`);
+  (0, import_build_utils19.debug)(`Installing ${dep}`);
   await uv.pip({
     venvPath,
     projectDir,
@@ -7573,23 +9011,29 @@ var build = async ({
   registerPreDeploy
 }) => {
   let entrypoint = rawEntrypoint === "<detect>" ? void 0 : rawEntrypoint;
-  const builderSpan = parentSpan ?? new import_build_utils18.Span({ name: "vc.builder" });
+  const builderSpan = parentSpan ?? new import_build_utils19.Span({ name: "vc.builder" });
   const framework = config?.framework;
-  const shouldInstallVercelWorkers = config?.hasWorkerServices === true;
+  let shouldInstallVercelWorkers = config?.hasWorkerServices === true;
+  let subscribers = [];
   let spawnEnv;
   let projectInstallCommand;
   let hasCustomCommand = false;
+  let hasCustomBuildCommand = false;
   const target = getTargetPlatform(meta.isDev ?? false);
-  (0, import_build_utils18.debug)(`workPath: ${workPath}`);
+  (0, import_build_utils19.debug)(`workPath: ${workPath}`);
   workPath = await downloadFilesInWorkPath({
     workPath,
     files: originalFiles,
     entrypoint,
     meta
   });
+  if (!service && (0, import_build_utils19.isPythonFramework)(framework)) {
+    subscribers = await getPyprojectSubscribers(workPath);
+    shouldInstallVercelWorkers ||= subscribers.length > 0;
+  }
   try {
     if (meta.isDev) {
-      const setupCfg = (0, import_path14.join)(workPath, "setup.cfg");
+      const setupCfg = (0, import_path15.join)(workPath, "setup.cfg");
       await writeFile(setupCfg, "[install]\nprefix=\n");
     }
   } catch (err) {
@@ -7605,15 +9049,15 @@ var build = async ({
       filePath: entrypoint,
       // For schedule-triggered jobs, the WSGI variable is always 'app' (created dynamically).
       // For other services, handlerFunction is used as the entrypoint variable name.
-      varName: service && (0, import_build_utils18.isScheduleTriggeredService)(service) ? void 0 : handlerFunction
+      varName: service && (0, import_build_utils19.isScheduleTriggeredService)(service) ? void 0 : handlerFunction
     } : void 0,
     service
   ) ?? void 0;
   if (detected?.error && detected?.baseDir === void 0) {
     throw detected?.error;
   }
-  const entryDirectory = detected?.baseDir ?? (entrypoint ? (0, import_path14.dirname)(entrypoint) : ".");
-  const entrypointAbsDir = (0, import_path14.join)(workPath, entryDirectory);
+  const entryDirectory = detected?.baseDir ?? (entrypoint ? (0, import_path15.dirname)(entrypoint) : ".");
+  const entrypointAbsDir = (0, import_path15.join)(workPath, entryDirectory);
   const rootDir = repoRootPath ?? workPath;
   const pythonPackage = await builderSpan.child("vc.builder.python.discover").trace(
     () => discoverPackage({
@@ -7646,22 +9090,20 @@ var build = async ({
   try {
     const uvPath = await getUvBinaryOrInstall(pythonVersion.pythonPath);
     uv = new UvRunner(uvPath, uvCacheDir);
-    const uvVersionOutput = (0, import_child_process3.execSync)(`${uvPath} --version`, {
-      encoding: "utf8"
-    }).trim();
-    console.log(`Using ${uvVersionOutput}`);
   } catch (err) {
     console.log("Failed to install or locate uv");
     throw new Error(
       `uv is required for this project but failed to install: ${err instanceof Error ? err.message : String(err)}`
     );
   }
-  const venvPath = service?.name ? (0, import_path14.join)(workPath, ".vercel", "python", "services", service.name, ".venv") : (0, import_path14.join)(workPath, ".vercel", "python", ".venv");
-  const hasCachedVenv = import_fs14.default.existsSync((0, import_path14.join)(venvPath, "pyvenv.cfg"));
-  const hasCachedUv = import_fs14.default.existsSync(uvCacheDir);
+  const uvVersion = checkUvBinaryVersion(uv.getPath());
+  console.log(`Using ${uvVersion}`);
+  const venvPath = service?.name ? (0, import_path15.join)(workPath, ".vercel", "python", "services", service.name, ".venv") : (0, import_path15.join)(workPath, ".vercel", "python", ".venv");
+  const hasCachedVenv = import_fs15.default.existsSync((0, import_path15.join)(venvPath, "pyvenv.cfg"));
+  const hasCachedUv = import_fs15.default.existsSync(uvCacheDir);
   const restoredCache = hasCachedVenv && hasCachedUv ? "both" : hasCachedVenv ? "venv" : hasCachedUv ? "uv" : "none";
   if (hasCachedVenv || hasCachedUv) {
-    (0, import_build_utils18.debug)(
+    (0, import_build_utils19.debug)(
       `Build cache detected: venv=${hasCachedVenv}, uv-cache=${hasCachedUv}`
     );
   }
@@ -7673,14 +9115,14 @@ var build = async ({
       uvCacheDir
     });
   });
-  if ((0, import_build_utils18.isPythonFramework)(framework)) {
+  if ((0, import_build_utils19.isPythonFramework)(framework)) {
     const {
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
       turboSupportsCorepackHome
-    } = await (0, import_build_utils18.scanParentDirs)(workPath, true);
-    spawnEnv = (0, import_build_utils18.getEnvForPackageManager)({
+    } = await (0, import_build_utils19.scanParentDirs)(workPath, true);
+    spawnEnv = (0, import_build_utils19.getEnvForPackageManager)({
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
@@ -7705,13 +9147,13 @@ var build = async ({
   let uvLockPath = null;
   let uvProjectDir = null;
   let projectName;
-  await builderSpan.child(import_build_utils18.BUILDER_INSTALLER_STEP, {
+  await builderSpan.child(import_build_utils19.BUILDER_INSTALLER_STEP, {
     installCommand: projectInstallCommand || void 0,
     runtime: "python",
     "python.cache.restored": restoredCache
   }).trace(async () => {
     if (projectInstallCommand) {
-      await import_fs14.default.promises.rm(venvPath, { recursive: true, force: true });
+      await import_fs15.default.promises.rm(venvPath, { recursive: true, force: true });
       await ensureVenv({
         pythonVersion,
         venvPath,
@@ -7722,7 +9164,7 @@ var build = async ({
       console.log(
         `Running "install" command: \`${projectInstallCommand}\`...`
       );
-      await (0, import_build_utils18.execCommand)(projectInstallCommand, {
+      await (0, import_build_utils19.execCommand)(projectInstallCommand, {
         env: pythonEnv,
         cwd: workPath
       });
@@ -7743,7 +9185,7 @@ var build = async ({
     }
     if (!assumeDepsInstalled) {
       const lockCacheKey = service?.name ? `uv.lock.${service.name}` : "uv.lock";
-      const cachedLockPath = (0, import_path14.join)(uvCacheDir, lockCacheKey);
+      const cachedLockPath = (0, import_path15.join)(uvCacheDir, lockCacheKey);
       const { projectDir, lockPath, lockFileProvidedByUser } = await ensureUvProject({
         workPath,
         rootDir,
@@ -7764,36 +9206,40 @@ var build = async ({
         locked: !lockFileProvidedByUser,
         pythonPlatform: target.uvPlatform
       });
-      if (lockPath && import_fs14.default.existsSync(lockPath)) {
-        await import_fs14.default.promises.mkdir(uvCacheDir, { recursive: true });
-        await import_fs14.default.promises.copyFile(lockPath, cachedLockPath);
+      if (lockPath && import_fs15.default.existsSync(lockPath)) {
+        await import_fs15.default.promises.mkdir(uvCacheDir, { recursive: true });
+        await import_fs15.default.promises.copyFile(lockPath, cachedLockPath);
       }
     }
   });
-  if ((0, import_build_utils18.isPythonFramework)(framework)) {
+  if ((0, import_build_utils19.isPythonFramework)(framework)) {
     const projectBuildCommand = config?.projectSettings?.buildCommand ?? // fallback if provided directly on config (some callers set this)
     config?.buildCommand;
-    await builderSpan.child(import_build_utils18.BUILDER_COMPILE_STEP, {
+    await builderSpan.child(import_build_utils19.BUILDER_COMPILE_STEP, {
       buildCommand: projectBuildCommand || void 0
     }).trace(async () => {
       if (projectBuildCommand) {
         console.log(`Running "${projectBuildCommand}"`);
-        await (0, import_build_utils18.execCommand)(projectBuildCommand, {
+        await (0, import_build_utils19.execCommand)(projectBuildCommand, {
           env: pythonEnv,
           cwd: workPath
         });
+        hasCustomBuildCommand = true;
       } else {
-        await runPyprojectScript(
+        const ranBuildScript = await runPyprojectScript(
           workPath,
           ["vercel-build", "now-build", "build"],
           pythonEnv
         );
+        if (ranBuildScript) {
+          hasCustomBuildCommand = true;
+        }
       }
     });
   }
   const hookResult = await runFrameworkHook(framework, {
     pythonEnv,
-    projectDir: (0, import_path14.join)(workPath, entryDirectory),
+    projectDir: (0, import_path15.join)(workPath, entryDirectory),
     workPath,
     venvPath,
     entrypoint,
@@ -7805,7 +9251,7 @@ var build = async ({
   }
   entrypoint = resolved?.entrypoint;
   if (!entrypoint) {
-    throw new import_build_utils18.NowBuildError({
+    throw new import_build_utils19.NowBuildError({
       code: "PYTHON_ENTRYPOINT_NOT_FOUND",
       message: "No Python entrypoint could be detected. Please specify an entrypoint file."
     });
@@ -7818,7 +9264,7 @@ var build = async ({
     envOverride: baseEnv.VERCEL_RUNTIME_PYTHON,
     uv,
     venvPath,
-    projectDir: (0, import_path14.join)(workPath, entryDirectory),
+    projectDir: (0, import_path15.join)(workPath, entryDirectory),
     pipPlatformArgs
   });
   if (shouldInstallVercelWorkers) {
@@ -7828,7 +9274,7 @@ var build = async ({
       envOverride: baseEnv.VERCEL_WORKERS_PYTHON,
       uv,
       venvPath,
-      projectDir: (0, import_path14.join)(workPath, entryDirectory),
+      projectDir: (0, import_path15.join)(workPath, entryDirectory),
       pipPlatformArgs
     });
   }
@@ -7841,25 +9287,25 @@ var build = async ({
     const capturedEnv = { ...pythonEnv };
     const capturedCwd = workPath;
     registerPreDeploy(async () => {
-      await builderSpan.child(import_build_utils18.BUILDER_PRE_DEPLOY_STEP, {
+      await builderSpan.child(import_build_utils19.BUILDER_PRE_DEPLOY_STEP, {
         preDeployCommand
       }).trace(async () => {
         console.log(`Running pre-deploy command: \`${preDeployCommand}\``);
-        await (0, import_build_utils18.execCommand)(preDeployCommand, {
+        await (0, import_build_utils19.execCommand)(preDeployCommand, {
           env: capturedEnv,
           cwd: capturedCwd
         });
       });
     });
   }
-  (0, import_build_utils18.debug)("Entrypoint is", entrypoint);
+  (0, import_build_utils19.debug)("Entrypoint is", entrypoint);
   const moduleName = entrypointToModule(entrypoint);
   if (handlerFunction) {
-    const entrypointPath = (0, import_path14.join)(workPath, entrypoint);
-    const source = await import_fs14.default.promises.readFile(entrypointPath, "utf-8");
+    const entrypointPath = (0, import_path15.join)(workPath, entrypoint);
+    const source = await import_fs15.default.promises.readFile(entrypointPath, "utf-8");
     const found = await (0, import_python_analysis9.containsTopLevelCallable)(source, handlerFunction);
     if (!found) {
-      throw new import_build_utils18.NowBuildError({
+      throw new import_build_utils19.NowBuildError({
         code: "PYTHON_HANDLER_NOT_FOUND",
         message: `Handler function "${handlerFunction}" not found in ${entrypoint}. Ensure it is defined at the module's top level.`
       });
@@ -7868,7 +9314,7 @@ var build = async ({
   const vendorDir = resolveVendorDir();
   const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
   const entrypointWithSuffix = `${entrypoint}${suffix}`;
-  (0, import_build_utils18.debug)("Entrypoint with suffix is", entrypointWithSuffix);
+  (0, import_build_utils19.debug)("Entrypoint with suffix is", entrypointWithSuffix);
   const crons = await getServiceCrons({
     service,
     entrypoint,
@@ -7878,56 +9324,24 @@ var build = async ({
     env: pythonEnv,
     workPath
   });
-  let cronEnvLine = "";
+  const extraTrampolineEnv = [];
   if (crons?.length) {
     const json = JSON.stringify(buildCronRouteTable(crons));
     (0, import_assert.default)(!json.includes("\\"), `backslash in cron route table: ${json}`);
-    cronEnvLine = `
-  "__VC_CRON_ROUTES": '${json}',`;
+    extraTrampolineEnv.push(`"__VC_CRON_ROUTES": '${json}'`);
   }
   const variableName = resolved?.variableName ?? "";
-  const runtimeTrampoline = `
-import importlib
-import os
-import os.path
-import site
-import sys
-
-_here = os.path.dirname(__file__)
-
-os.environ.update({
-  "__VC_HANDLER_MODULE_NAME": "${moduleName}",
-  "__VC_HANDLER_ENTRYPOINT": "${entrypointWithSuffix}",
-  "__VC_HANDLER_ENTRYPOINT_ABS": os.path.join(_here, "${entrypointWithSuffix}"),
-  "__VC_HANDLER_VENDOR_DIR": "${vendorDir}",
-  "__VC_HANDLER_VARIABLE_NAME": "${variableName}",${cronEnvLine}
-})
-
-_vendor_rel = '${vendorDir}'
-_vendor = os.path.normpath(os.path.join(_here, _vendor_rel))
-
-if os.path.isdir(_vendor):
-    # Process .pth files like a real site-packages dir
-    site.addsitedir(_vendor)
-
-    # Move _vendor to the front (after script dir if present)
-    try:
-        while _vendor in sys.path:
-            sys.path.remove(_vendor)
-    except ValueError:
-        pass
-
-    # Put vendored deps ahead of site-packages but after the script dir
-    idx = 1 if (sys.path and sys.path[0] in ('', _here)) else 0
-    sys.path.insert(idx, _vendor)
-
-    importlib.invalidate_caches()
-
-from vercel_runtime.vc_init import vc_handler
-`;
+  const runtimeTrampoline = createRuntimeTrampoline({
+    moduleName,
+    entrypoint: entrypointWithSuffix,
+    vendorDir,
+    variableName,
+    extraEnv: extraTrampolineEnv
+  });
   const automaticCompileAllEnabled = shouldUseCompileAll({
     isDev: meta.isDev,
-    hasCustomCommand
+    hasCustomCommand,
+    hasCustomBuildCommand
   });
   const predefinedExcludes = [
     ".git/**",
@@ -7958,17 +9372,16 @@ from vercel_runtime.vc_init import vc_handler
     cwd: workPath,
     ignore: config && typeof config.excludeFiles === "string" ? [...predefinedExcludes, config.excludeFiles] : predefinedExcludes
   };
-  const files = await (0, import_build_utils18.glob)("**", globOptions);
+  const files = await (0, import_build_utils19.glob)("**", globOptions);
   if (djangoStatic?.manifestRelPath) {
-    files[djangoStatic.manifestRelPath] = new import_build_utils18.FileFsRef({
-      fsPath: (0, import_path14.join)(workPath, djangoStatic.manifestRelPath)
+    files[djangoStatic.manifestRelPath] = new import_build_utils19.FileFsRef({
+      fsPath: (0, import_path15.join)(workPath, djangoStatic.manifestRelPath)
     });
   }
   const handlerPyFilename = "vc__handler__python";
-  files[`${handlerPyFilename}.py`] = new import_build_utils18.FileBlob({ data: runtimeTrampoline });
   if (config.framework === "fasthtml") {
     const { SESSKEY = "" } = process.env;
-    files[".sesskey"] = new import_build_utils18.FileBlob({ data: `"${SESSKEY}"` });
+    files[".sesskey"] = new import_build_utils19.FileBlob({ data: `"${SESSKEY}"` });
   }
   const depExternalizer = new PythonDependencyExternalizer({
     venvPath,
@@ -7987,81 +9400,136 @@ from vercel_runtime.vc_init import vc_handler
     ]
   });
   await builderSpan.child("vc.builder.python.bundle").trace(async (bundleSpan) => {
-    const depAnalysis = await depExternalizer.analyze(files);
-    bundleSpan.setAttributes({
-      "python.bundle.totalSizeBytes": String(depAnalysis.totalBundleSize),
-      "python.bundle.runtimeInstallEnabled": String(
-        depAnalysis.runtimeInstallEnabled
-      )
+    const depAnalysis = await depExternalizer.analyze(files, {
+      onSized: ({ totalSizeBytes, runtimeInstallEnabled }) => {
+        bundleSpan.setAttributes({
+          "python.bundle.totalSizeBytes": String(totalSizeBytes),
+          "python.bundle.runtimeInstallEnabled": String(
+            runtimeInstallEnabled
+          )
+        });
+      }
     });
-    if (depAnalysis.runtimeInstallEnabled) {
-      await depExternalizer.generateBundle(files);
-    } else {
-      addFiles(files, depAnalysis.allVendorFiles);
-      if (automaticCompileAllEnabled) {
-        await builderSpan.child("vc.builder.python.compileall").trace(async (compileSpan) => {
-          const sitePackageDirs = (await getVenvSitePackagesDirs(venvPath)).filter((d) => import_fs14.default.existsSync(d));
-          const pythonBin = getVenvPythonBin(venvPath);
-          console.log("Compiling Python application bytecode...");
-          await runCompileAll({
-            pythonBin,
-            filesOrDirectories: [workPath],
-            env: pythonEnv,
-            excludeRegex: getCompileAllAppExcludeRegex(workPath)
-          });
-          console.log("Compiling Python dependency bytecode...");
-          await runCompileAll({
-            pythonBin,
-            filesOrDirectories: sitePackageDirs,
-            env: pythonEnv
-          });
-          compileSpan.setAttributes({
-            "python.compileall.enabled": "true",
-            "python.compileall.sitePackageDirectoryCount": String(
-              sitePackageDirs.length
-            )
-          });
+    const runCompileAllAndFillBytecode = async () => {
+      await builderSpan.child("vc.builder.python.compileall").trace(async (compileSpan) => {
+        const sitePackageDirs = (await getVenvSitePackagesDirs(venvPath)).filter((d) => import_fs15.default.existsSync(d));
+        const pythonBin = getVenvPythonBin(venvPath);
+        console.log("Compiling Python application bytecode...");
+        await runCompileAll({
+          pythonBin,
+          filesOrDirectories: [workPath],
+          env: pythonEnv,
+          excludeRegex: getCompileAllAppExcludeRegex(workPath)
         });
-        const pythonOnHiveEnabled = process.env.VERCEL_PYTHON_ON_HIVE === "1" || process.env.VERCEL_PYTHON_ON_HIVE === "true";
-        const activeThreshold = pythonOnHiveEnabled ? HIVE_LAMBDA_SIZE_BYTES : LAMBDA_SIZE_THRESHOLD_BYTES;
-        const currentSize = await calculateBundleSize(files);
-        let remainingCapacity = activeThreshold - currentSize;
-        if (pythonVersion.major != null && pythonVersion.minor != null) {
-          const appBytecodeInfo = await collectAppBytecodeFiles({
-            workPath,
-            files,
-            pythonMajor: pythonVersion.major,
-            pythonMinor: pythonVersion.minor
-          });
-          remainingCapacity = addBytecodeWithinCapacity(
-            files,
-            appBytecodeInfo,
-            remainingCapacity
-          );
-        }
-        const vendorBytecodeInfo = await depExternalizer.collectBytecodeFiles(
-          {
-            vendorDirName: vendorDir
-          }
-        );
-        await addVendorBytecodeWithinCapacity({
+        console.log("Compiling Python dependency bytecode...");
+        await runCompileAll({
+          pythonBin,
+          filesOrDirectories: sitePackageDirs,
+          env: pythonEnv
+        });
+        compileSpan.setAttributes({
+          "python.compileall.enabled": "true",
+          "python.compileall.sitePackageDirectoryCount": String(
+            sitePackageDirs.length
+          )
+        });
+      });
+      const currentSize = await calculateBundleSize(files);
+      let remainingCapacity = MAX_LARGE_FUNCTION_UNCOMPRESSED_SIZE - currentSize;
+      if (pythonVersion.major != null && pythonVersion.minor != null) {
+        const appBytecodeInfo = await collectAppBytecodeFiles({
+          workPath,
           files,
-          depExternalizer,
-          vendorDir,
-          bytecodeInfo: vendorBytecodeInfo,
-          capacity: remainingCapacity
+          pythonMajor: pythonVersion.major,
+          pythonMinor: pythonVersion.minor
         });
+        remainingCapacity = addBytecodeWithinCapacity(
+          files,
+          appBytecodeInfo,
+          remainingCapacity
+        );
+      }
+      const vendorBytecodeInfo = await depExternalizer.collectBytecodeFiles({
+        vendorDirName: vendorDir
+      });
+      await addVendorBytecodeWithinCapacity({
+        files,
+        depExternalizer,
+        vendorDir,
+        bytecodeInfo: vendorBytecodeInfo,
+        capacity: remainingCapacity
+      });
+    };
+    const announceLargeFunction = () => console.log(
+      `Function "${entrypoint}" exceeds the standard size limit; enabling large functions (beta).`
+    );
+    if (depAnalysis.runtimeInstallEnabled) {
+      const { fellBackToFullBundle } = await depExternalizer.generateBundle(files);
+      if (fellBackToFullBundle) {
+        announceLargeFunction();
+        if (automaticCompileAllEnabled) {
+          await runCompileAllAndFillBytecode();
+        }
+      }
+    } else {
+      addFiles(files, depAnalysis.allVendorFiles);
+      if (isLargeFunctionsEnabled() && depAnalysis.totalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES) {
+        announceLargeFunction();
+      }
+      if (automaticCompileAllEnabled && depAnalysis.totalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES) {
+        await runCompileAllAndFillBytecode();
       }
     }
   });
-  const output = new import_build_utils18.Lambda({
-    files,
+  const webFiles = {
+    ...files,
+    [`${handlerPyFilename}.py`]: new import_build_utils19.FileBlob({ data: runtimeTrampoline })
+  };
+  const output = new import_build_utils19.Lambda({
+    files: webFiles,
     handler: `${handlerPyFilename}.vc_handler`,
     runtime: pythonVersion.runtime,
     architecture: target.architecture,
     environment: lambdaEnv,
     supportsResponseStreaming: true
   });
+  const subscriberLambdas = {};
+  for (const subscriber of subscribers) {
+    const safeName = safePathSegment(subscriber.name);
+    const outputPath = `_py_subscribers/${safeName}`;
+    const consumer = (0, import_build_utils19.sanitizeConsumerName)(outputPath);
+    const experimentalTriggers = subscriber.topics.map(
+      (topic) => ({
+        type: "queue/v2beta",
+        topic,
+        consumer,
+        ...subscriber.triggerDefaults
+      })
+    );
+    subscriberLambdas[outputPath] = new import_build_utils19.Lambda({
+      files: {
+        ...files,
+        [`${handlerPyFilename}.py`]: new import_build_utils19.FileBlob({
+          data: createRuntimeTrampoline({
+            moduleName: subscriber.moduleName,
+            entrypoint: subscriber.entrypoint,
+            vendorDir,
+            variableName: subscriber.variableName
+          })
+        })
+      },
+      handler: `${handlerPyFilename}.vc_handler`,
+      runtime: pythonVersion.runtime,
+      architecture: target.architecture,
+      environment: {
+        ...lambdaEnv,
+        VERCEL_HAS_WORKER_SERVICES: "1",
+        VERCEL_SERVICE_TYPE: "worker"
+      },
+      experimentalTriggers,
+      supportsResponseStreaming: true
+    });
+  }
   if (uvLockPath && !meta.isDev) {
     try {
       await generateProjectManifest({
@@ -8070,25 +9538,30 @@ from vercel_runtime.vc_init import vc_handler
         pythonVersion,
         uvLockPath,
         framework,
-        serviceType: service ? (0, import_build_utils18.getReportedServiceType)(service) : void 0
+        serviceType: service ? (0, import_build_utils19.getReportedServiceType)(service) : void 0
       });
     } catch (err) {
-      (0, import_build_utils18.debug)(
+      (0, import_build_utils19.debug)(
         `Failed to write project manifest: ${err instanceof Error ? err.message : String(err)}`
       );
     }
   }
-  if (!(0, import_build_utils18.isPythonFramework)(framework) && !service?.name) {
+  if (!(0, import_build_utils19.isPythonFramework)(framework) && !service?.name) {
     return { resultVersion: 3, result: { output } };
   }
   const lambdaPath = service?.name ? `_svc/${service.name}/index` : "index";
-  const staticFiles = djangoStatic?.cdnOutputDir ? await (0, import_build_utils18.glob)("**", { cwd: djangoStatic.cdnOutputDir }) : {};
-  const routes = service?.name ? void 0 : [{ handle: "filesystem" }, { src: "/(.*)", dest: `/${lambdaPath}` }];
+  const staticFiles = djangoStatic?.cdnOutputDir ? await (0, import_build_utils19.glob)("**", { cwd: djangoStatic.cdnOutputDir }) : {};
+  const isNonWebService = service?.name && service.type && service.type !== "web";
+  const routes = isNonWebService ? void 0 : [
+    { handle: "filesystem" },
+    { src: "/(.*)", dest: `/${lambdaPath}` }
+  ];
   return {
     resultVersion: 2,
     result: {
       output: {
         [lambdaPath]: output,
+        ...subscriberLambdas,
         ...staticFiles
       },
       ...routes ? { routes } : {},
@@ -8111,14 +9584,14 @@ var prepareCache = async ({
     }
   } catch {
   }
-  return (0, import_build_utils18.glob)("**/.vercel/python/{.venv,services/*/.venv,cache/uv}/**", {
+  return (0, import_build_utils19.glob)("**/.vercel/python/{.venv,services/*/.venv,cache/uv}/**", {
     cwd: root,
     ignore
   });
 };
 var shouldServe = (opts) => {
   const framework = opts.config.framework;
-  if ((0, import_build_utils18.isPythonFramework)(framework)) {
+  if ((0, import_build_utils19.isPythonFramework)(framework)) {
     const requestPath = opts.requestPath.replace(/\/$/, "");
     if (requestPath.startsWith("api") && opts.hasMatched) {
       return false;
@@ -8137,7 +9610,7 @@ var defaultShouldServe = ({
   if (entrypoint === requestPath && hasProp(files, entrypoint)) {
     return true;
   }
-  const { dir, name } = (0, import_path14.parse)(entrypoint);
+  const { dir, name } = (0, import_path15.parse)(entrypoint);
   if (name === "index" && dir === requestPath && hasProp(files, entrypoint)) {
     return true;
   }