@vercel/python 6.45.0 → 6.47.0

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"];
@@ -3518,6 +4669,38 @@ async function findUvBinary(pythonPath) {
   }
   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);
   if (uvBin)
@@ -4466,17 +5649,18 @@ 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");
+function isPythonOnHive() {
+  const hive = process.env.VERCEL_PYTHON_ON_HIVE;
+  return hive === "1" || hive === "true";
+}
 function isCompileAllEnabled() {
+  if (!isPythonOnHive())
+    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,
@@ -4484,11 +5668,6 @@ function shouldUseCompileAll({
 }) {
   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)
     return false;
   return isCompileAllEnabled();
@@ -4614,14 +5793,7 @@ 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_EPHEMERAL_STORAGE_BYTES = 500 * 1024 * 1024;
 var HIVE_LAMBDA_SIZE_BYTES = 1 * 1024 * 1024 * 1024;
-var FUNCTIONS_BETA_CTA = "Run `vercel deploy --functions-beta` to use extended function limits (up to 1 GB), or reduce your dependency footprint.";
 var BUNDLING_DOCS_LINK = "https://vercel.com/docs/functions/runtimes/python#controlling-what-gets-bundled";
-var FUNCTIONS_BETA_DOCS_LINK = "https://vercel.com/docs/functions/runtimes/python#extended-size-limits-with-functions-beta";
-var FUNCTIONS_BETA_EXCEEDED_CTA = "Your deployment is already using extended function limits (`--functions-beta`).\nReduce your dependency footprint to under 1 GB or split your application\ninto smaller functions.";
-function shouldShowFunctionsBetaHint() {
-  const v = process.env.VERCEL_FUNCTIONS_BETA_HINT;
-  return v === "1" || v === "true";
-}
 var PythonDependencyExternalizer = class {
   constructor(options) {
     // Populated by analyze()
@@ -4659,7 +5831,7 @@ var PythonDependencyExternalizer = class {
    * 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) {
@@ -4683,13 +5855,15 @@ var PythonDependencyExternalizer = class {
     (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";
+    options.onSized?.({
+      totalSizeBytes: this.totalBundleSize,
+      runtimeInstallEnabled
+    });
     if (this.totalBundleSize > LAMBDA_SIZE_THRESHOLD_BYTES && this.hasCustomCommand && !pythonOnHiveEnabled) {
       const limitMB = (LAMBDA_SIZE_THRESHOLD_BYTES / (1024 * 1024)).toFixed(0);
       throw new import_build_utils7.NowBuildError({
         code: "LAMBDA_SIZE_EXCEEDED",
-        message: shouldShowFunctionsBetaHint() ? `Total bundle size (${totalBundleSizeMB} MB) exceeds the size limit (${limitMB} MB).
-
-` + FUNCTIONS_BETA_CTA : `Total bundle size (${totalBundleSizeMB} MB) exceeds the size limit (${limitMB} MB).
+        message: `Total bundle size (${totalBundleSizeMB} MB) exceeds the size limit (${limitMB} MB).
 
 When using a custom install command, Vercel cannot automatically
 optimize dependency bundling. To reduce the size of your
@@ -4697,7 +5871,7 @@ 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.`,
-        link: shouldShowFunctionsBetaHint() ? FUNCTIONS_BETA_DOCS_LINK : BUNDLING_DOCS_LINK,
+        link: BUNDLING_DOCS_LINK,
         action: "Learn More"
       });
     }
@@ -4705,13 +5879,11 @@ dependencies, you can:
       const limitMB = (HIVE_LAMBDA_SIZE_BYTES / (1024 * 1024)).toFixed(0);
       throw new import_build_utils7.NowBuildError({
         code: "LAMBDA_SIZE_EXCEEDED",
-        message: shouldShowFunctionsBetaHint() ? `Total bundle size (${totalBundleSizeMB} MB) exceeds the extended function size limit (${limitMB} MB).
-
-` + FUNCTIONS_BETA_EXCEEDED_CTA : `Total bundle size (${totalBundleSizeMB} MB) exceeds the extended function size limit (${limitMB} MB).
+        message: `Total bundle size (${totalBundleSizeMB} MB) exceeds the extended function size limit (${limitMB} MB).
 
 Consider removing unused dependencies or splitting your
 application into smaller functions.`,
-        link: "https://vercel.com/docs/functions/runtimes/python#controlling-what-gets-bundled",
+        link: BUNDLING_DOCS_LINK,
         action: "Learn More"
       });
     }
@@ -4747,15 +5919,13 @@ application into smaller functions.`,
       const ephemeralLimitMB = (LAMBDA_EPHEMERAL_STORAGE_BYTES / (1024 * 1024)).toFixed(0);
       throw new import_build_utils7.NowBuildError({
         code: "LAMBDA_SIZE_EXCEEDED",
-        message: shouldShowFunctionsBetaHint() ? `Total bundle size (${totalBundleSizeMB} MB) exceeds the ephemeral storage limit (${ephemeralLimitMB} MB).
-
-` + FUNCTIONS_BETA_CTA : `Total bundle size (${totalBundleSizeMB} MB) exceeds Lambda ephemeral storage limit (${ephemeralLimitMB} MB).
+        message: `Total bundle size (${totalBundleSizeMB} MB) exceeds Lambda ephemeral storage limit (${ephemeralLimitMB} 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.`,
-        link: shouldShowFunctionsBetaHint() ? FUNCTIONS_BETA_DOCS_LINK : BUNDLING_DOCS_LINK,
+        link: BUNDLING_DOCS_LINK,
         action: "Learn More"
       });
     }
@@ -4946,15 +6116,13 @@ To fix this, either:
       const limitMB = (LAMBDA_SIZE_THRESHOLD_BYTES / (1024 * 1024)).toFixed(0);
       throw new import_build_utils7.NowBuildError({
         code: "LAMBDA_SIZE_EXCEEDED",
-        message: shouldShowFunctionsBetaHint() ? `Total bundle size (${finalSizeMB} MB) exceeds the size limit (${limitMB} MB).
-
-` + FUNCTIONS_BETA_CTA : `Total bundle size (${finalSizeMB} MB) exceeds Lambda limit (${limitMB} MB) even after
+        message: `Total bundle size (${finalSizeMB} MB) exceeds Lambda limit (${limitMB} MB) even after
 deferring public packages to runtime installation.
 
 This usually means your private packages or source code are too
 large. Consider reducing the size of private dependencies or
 splitting your application.`,
-        link: shouldShowFunctionsBetaHint() ? FUNCTIONS_BETA_DOCS_LINK : BUNDLING_DOCS_LINK,
+        link: BUNDLING_DOCS_LINK,
         action: "Learn More"
       });
     }
@@ -6618,6 +7786,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;
@@ -7375,7 +8546,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) {
@@ -7439,7 +8780,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;
@@ -7453,13 +8794,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`);
@@ -7472,7 +8813,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"];
@@ -7481,7 +8822,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 };
@@ -7489,7 +8830,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,
@@ -7503,29 +8844,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;
@@ -7558,11 +8948,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,
@@ -7588,23 +8978,28 @@ 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;
   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) {
@@ -7620,15 +9015,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({
@@ -7661,22 +9056,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}`
     );
   }
@@ -7688,14 +9081,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,
@@ -7720,13 +9113,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,
@@ -7737,7 +9130,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
       });
@@ -7758,7 +9151,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,
@@ -7779,21 +9172,21 @@ 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
         });
@@ -7808,7 +9201,7 @@ var build = async ({
   }
   const hookResult = await runFrameworkHook(framework, {
     pythonEnv,
-    projectDir: (0, import_path14.join)(workPath, entryDirectory),
+    projectDir: (0, import_path15.join)(workPath, entryDirectory),
     workPath,
     venvPath,
     entrypoint,
@@ -7820,7 +9213,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."
     });
@@ -7833,7 +9226,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) {
@@ -7843,7 +9236,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
     });
   }
@@ -7856,25 +9249,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.`
       });
@@ -7883,7 +9276,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,
@@ -7893,53 +9286,20 @@ 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
@@ -7973,17 +9333,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,
@@ -8002,12 +9361,15 @@ 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);
@@ -8015,7 +9377,7 @@ from vercel_runtime.vc_init import vc_handler
       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 sitePackageDirs = (await getVenvSitePackagesDirs(venvPath)).filter((d) => import_fs15.default.existsSync(d));
           const pythonBin = getVenvPythonBin(venvPath);
           console.log("Compiling Python application bytecode...");
           await runCompileAll({
@@ -8037,10 +9399,8 @@ from vercel_runtime.vc_init import vc_handler
             )
           });
         });
-        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;
+        let remainingCapacity = HIVE_LAMBDA_SIZE_BYTES - currentSize;
         if (pythonVersion.major != null && pythonVersion.minor != null) {
           const appBytecodeInfo = await collectAppBytecodeFiles({
             workPath,
@@ -8069,14 +9429,55 @@ from vercel_runtime.vc_init import vc_handler
       }
     }
   });
-  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({
@@ -8085,25 +9486,26 @@ 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 staticFiles = djangoStatic?.cdnOutputDir ? await (0, import_build_utils19.glob)("**", { cwd: djangoStatic.cdnOutputDir }) : {};
   const routes = service?.name ? void 0 : [{ handle: "filesystem" }, { src: "/(.*)", dest: `/${lambdaPath}` }];
   return {
     resultVersion: 2,
     result: {
       output: {
         [lambdaPath]: output,
+        ...subscriberLambdas,
         ...staticFiles
       },
       ...routes ? { routes } : {},
@@ -8126,14 +9528,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;
@@ -8152,7 +9554,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;
   }