@vercel/build-utils 14.0.5 → 14.1.1

package/dist/index.js

@@ -341,7 +341,7 @@ var require_BufferList = __commonJS({
         this.head = this.tail = null;
         this.length = 0;
       };
-      BufferList.prototype.join = function join9(s) {
+      BufferList.prototype.join = function join10(s) {
         if (this.length === 0)
           return "";
         var p = this.head;
@@ -11343,7 +11343,7 @@ var require_cross_spawn = __commonJS({
     var cp = require("child_process");
     var parse6 = require_parse();
     var enoent = require_enoent();
-    function spawn2(command, args, options) {
+    function spawn3(command, args, options) {
       const parsed = parse6(command, args, options);
       const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
@@ -11355,8 +11355,8 @@ var require_cross_spawn = __commonJS({
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
     }
-    module2.exports = spawn2;
-    module2.exports.spawn = spawn2;
+    module2.exports = spawn3;
+    module2.exports.spawn = spawn3;
     module2.exports.sync = spawnSync;
     module2.exports._parse = parse6;
     module2.exports._enoent = enoent;
@@ -23103,6 +23103,2774 @@ var require_lib4 = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/path-to-regexp@6.1.0/node_modules/path-to-regexp/dist/index.js
+var require_dist2 = __commonJS({
+  "../../node_modules/.pnpm/path-to-regexp@6.1.0/node_modules/path-to-regexp/dist/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    function lexer(str) {
+      var tokens = [];
+      var i = 0;
+      while (i < str.length) {
+        var char = str[i];
+        if (char === "*" || char === "+" || char === "?") {
+          tokens.push({ type: "MODIFIER", index: i, value: str[i++] });
+          continue;
+        }
+        if (char === "\\") {
+          tokens.push({ type: "ESCAPED_CHAR", index: i++, value: str[i++] });
+          continue;
+        }
+        if (char === "{") {
+          tokens.push({ type: "OPEN", index: i, value: str[i++] });
+          continue;
+        }
+        if (char === "}") {
+          tokens.push({ type: "CLOSE", index: i, value: str[i++] });
+          continue;
+        }
+        if (char === ":") {
+          var name = "";
+          var j = i + 1;
+          while (j < str.length) {
+            var code = str.charCodeAt(j);
+            if (
+              // `0-9`
+              code >= 48 && code <= 57 || // `A-Z`
+              code >= 65 && code <= 90 || // `a-z`
+              code >= 97 && code <= 122 || // `_`
+              code === 95
+            ) {
+              name += str[j++];
+              continue;
+            }
+            break;
+          }
+          if (!name)
+            throw new TypeError("Missing parameter name at " + i);
+          tokens.push({ type: "NAME", index: i, value: name });
+          i = j;
+          continue;
+        }
+        if (char === "(") {
+          var count = 1;
+          var pattern = "";
+          var j = i + 1;
+          if (str[j] === "?") {
+            throw new TypeError('Pattern cannot start with "?" at ' + j);
+          }
+          while (j < str.length) {
+            if (str[j] === "\\") {
+              pattern += str[j++] + str[j++];
+              continue;
+            }
+            if (str[j] === ")") {
+              count--;
+              if (count === 0) {
+                j++;
+                break;
+              }
+            } else if (str[j] === "(") {
+              count++;
+              if (str[j + 1] !== "?") {
+                throw new TypeError("Capturing groups are not allowed at " + j);
+              }
+            }
+            pattern += str[j++];
+          }
+          if (count)
+            throw new TypeError("Unbalanced pattern at " + i);
+          if (!pattern)
+            throw new TypeError("Missing pattern at " + i);
+          tokens.push({ type: "PATTERN", index: i, value: pattern });
+          i = j;
+          continue;
+        }
+        tokens.push({ type: "CHAR", index: i, value: str[i++] });
+      }
+      tokens.push({ type: "END", index: i, value: "" });
+      return tokens;
+    }
+    function parse6(str, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var tokens = lexer(str);
+      var _a = options.prefixes, prefixes = _a === void 0 ? "./" : _a;
+      var defaultPattern = "[^" + escapeString(options.delimiter || "/#?") + "]+?";
+      var result = [];
+      var key = 0;
+      var i = 0;
+      var path8 = "";
+      var tryConsume = function(type) {
+        if (i < tokens.length && tokens[i].type === type)
+          return tokens[i++].value;
+      };
+      var mustConsume = function(type) {
+        var value2 = tryConsume(type);
+        if (value2 !== void 0)
+          return value2;
+        var _a2 = tokens[i], nextType = _a2.type, index = _a2.index;
+        throw new TypeError("Unexpected " + nextType + " at " + index + ", expected " + type);
+      };
+      var consumeText = function() {
+        var result2 = "";
+        var value2;
+        while (value2 = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR")) {
+          result2 += value2;
+        }
+        return result2;
+      };
+      while (i < tokens.length) {
+        var char = tryConsume("CHAR");
+        var name = tryConsume("NAME");
+        var pattern = tryConsume("PATTERN");
+        if (name || pattern) {
+          var prefix = char || "";
+          if (prefixes.indexOf(prefix) === -1) {
+            path8 += prefix;
+            prefix = "";
+          }
+          if (path8) {
+            result.push(path8);
+            path8 = "";
+          }
+          result.push({
+            name: name || key++,
+            prefix,
+            suffix: "",
+            pattern: pattern || defaultPattern,
+            modifier: tryConsume("MODIFIER") || ""
+          });
+          continue;
+        }
+        var value = char || tryConsume("ESCAPED_CHAR");
+        if (value) {
+          path8 += value;
+          continue;
+        }
+        if (path8) {
+          result.push(path8);
+          path8 = "";
+        }
+        var open = tryConsume("OPEN");
+        if (open) {
+          var prefix = consumeText();
+          var name_1 = tryConsume("NAME") || "";
+          var pattern_1 = tryConsume("PATTERN") || "";
+          var suffix = consumeText();
+          mustConsume("CLOSE");
+          result.push({
+            name: name_1 || (pattern_1 ? key++ : ""),
+            pattern: name_1 && !pattern_1 ? defaultPattern : pattern_1,
+            prefix,
+            suffix,
+            modifier: tryConsume("MODIFIER") || ""
+          });
+          continue;
+        }
+        mustConsume("END");
+      }
+      return result;
+    }
+    exports.parse = parse6;
+    function compile(str, options) {
+      return tokensToFunction(parse6(str, options), options);
+    }
+    exports.compile = compile;
+    function tokensToFunction(tokens, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var reFlags = flags(options);
+      var _a = options.encode, encode = _a === void 0 ? function(x) {
+        return x;
+      } : _a, _b = options.validate, validate = _b === void 0 ? true : _b;
+      var matches = tokens.map(function(token) {
+        if (typeof token === "object") {
+          return new RegExp("^(?:" + token.pattern + ")$", reFlags);
+        }
+      });
+      return function(data) {
+        var path8 = "";
+        for (var i = 0; i < tokens.length; i++) {
+          var token = tokens[i];
+          if (typeof token === "string") {
+            path8 += token;
+            continue;
+          }
+          var value = data ? data[token.name] : void 0;
+          var optional = token.modifier === "?" || token.modifier === "*";
+          var repeat = token.modifier === "*" || token.modifier === "+";
+          if (Array.isArray(value)) {
+            if (!repeat) {
+              throw new TypeError('Expected "' + token.name + '" to not repeat, but got an array');
+            }
+            if (value.length === 0) {
+              if (optional)
+                continue;
+              throw new TypeError('Expected "' + token.name + '" to not be empty');
+            }
+            for (var j = 0; j < value.length; j++) {
+              var segment = encode(value[j], token);
+              if (validate && !matches[i].test(segment)) {
+                throw new TypeError('Expected all "' + token.name + '" to match "' + token.pattern + '", but got "' + segment + '"');
+              }
+              path8 += token.prefix + segment + token.suffix;
+            }
+            continue;
+          }
+          if (typeof value === "string" || typeof value === "number") {
+            var segment = encode(String(value), token);
+            if (validate && !matches[i].test(segment)) {
+              throw new TypeError('Expected "' + token.name + '" to match "' + token.pattern + '", but got "' + segment + '"');
+            }
+            path8 += token.prefix + segment + token.suffix;
+            continue;
+          }
+          if (optional)
+            continue;
+          var typeOfMessage = repeat ? "an array" : "a string";
+          throw new TypeError('Expected "' + token.name + '" to be ' + typeOfMessage);
+        }
+        return path8;
+      };
+    }
+    exports.tokensToFunction = tokensToFunction;
+    function match(str, options) {
+      var keys = [];
+      var re = pathToRegexp3(str, keys, options);
+      return regexpToFunction(re, keys, options);
+    }
+    exports.match = match;
+    function regexpToFunction(re, keys, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var _a = options.decode, decode = _a === void 0 ? function(x) {
+        return x;
+      } : _a;
+      return function(pathname) {
+        var m = re.exec(pathname);
+        if (!m)
+          return false;
+        var path8 = m[0], index = m.index;
+        var params = /* @__PURE__ */ Object.create(null);
+        var _loop_1 = function(i2) {
+          if (m[i2] === void 0)
+            return "continue";
+          var key = keys[i2 - 1];
+          if (key.modifier === "*" || key.modifier === "+") {
+            params[key.name] = m[i2].split(key.prefix + key.suffix).map(function(value) {
+              return decode(value, key);
+            });
+          } else {
+            params[key.name] = decode(m[i2], key);
+          }
+        };
+        for (var i = 1; i < m.length; i++) {
+          _loop_1(i);
+        }
+        return { path: path8, index, params };
+      };
+    }
+    exports.regexpToFunction = regexpToFunction;
+    function escapeString(str) {
+      return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+    }
+    function flags(options) {
+      return options && options.sensitive ? "" : "i";
+    }
+    function regexpToRegexp(path8, keys) {
+      if (!keys)
+        return path8;
+      var groups = path8.source.match(/\((?!\?)/g);
+      if (groups) {
+        for (var i = 0; i < groups.length; i++) {
+          keys.push({
+            name: i,
+            prefix: "",
+            suffix: "",
+            modifier: "",
+            pattern: ""
+          });
+        }
+      }
+      return path8;
+    }
+    function arrayToRegexp(paths, keys, options) {
+      var parts = paths.map(function(path8) {
+        return pathToRegexp3(path8, keys, options).source;
+      });
+      return new RegExp("(?:" + parts.join("|") + ")", flags(options));
+    }
+    function stringToRegexp(path8, keys, options) {
+      return tokensToRegexp(parse6(path8, options), keys, options);
+    }
+    function tokensToRegexp(tokens, keys, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var _a = options.strict, strict = _a === void 0 ? false : _a, _b = options.start, start = _b === void 0 ? true : _b, _c = options.end, end = _c === void 0 ? true : _c, _d = options.encode, encode = _d === void 0 ? function(x) {
+        return x;
+      } : _d;
+      var endsWith = "[" + escapeString(options.endsWith || "") + "]|$";
+      var delimiter = "[" + escapeString(options.delimiter || "/#?") + "]";
+      var route = start ? "^" : "";
+      for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
+        var token = tokens_1[_i];
+        if (typeof token === "string") {
+          route += escapeString(encode(token));
+        } else {
+          var prefix = escapeString(encode(token.prefix));
+          var suffix = escapeString(encode(token.suffix));
+          if (token.pattern) {
+            if (keys)
+              keys.push(token);
+            if (prefix || suffix) {
+              if (token.modifier === "+" || token.modifier === "*") {
+                var mod = token.modifier === "*" ? "?" : "";
+                route += "(?:" + prefix + "((?:" + token.pattern + ")(?:" + suffix + prefix + "(?:" + token.pattern + "))*)" + suffix + ")" + mod;
+              } else {
+                route += "(?:" + prefix + "(" + token.pattern + ")" + suffix + ")" + token.modifier;
+              }
+            } else {
+              route += "(" + token.pattern + ")" + token.modifier;
+            }
+          } else {
+            route += "(?:" + prefix + suffix + ")" + token.modifier;
+          }
+        }
+      }
+      if (end) {
+        if (!strict)
+          route += delimiter + "?";
+        route += !options.endsWith ? "$" : "(?=" + endsWith + ")";
+      } else {
+        var endToken = tokens[tokens.length - 1];
+        var isEndDelimited = typeof endToken === "string" ? delimiter.indexOf(endToken[endToken.length - 1]) > -1 : (
+          // tslint:disable-next-line
+          endToken === void 0
+        );
+        if (!strict) {
+          route += "(?:" + delimiter + "(?=" + endsWith + "))?";
+        }
+        if (!isEndDelimited) {
+          route += "(?=" + delimiter + "|" + endsWith + ")";
+        }
+      }
+      return new RegExp(route, flags(options));
+    }
+    exports.tokensToRegexp = tokensToRegexp;
+    function pathToRegexp3(path8, keys, options) {
+      if (path8 instanceof RegExp)
+        return regexpToRegexp(path8, keys);
+      if (Array.isArray(path8))
+        return arrayToRegexp(path8, keys, options);
+      return stringToRegexp(path8, keys, options);
+    }
+    exports.pathToRegexp = pathToRegexp3;
+  }
+});
+
+// ../../node_modules/.pnpm/path-to-regexp@6.3.0/node_modules/path-to-regexp/dist/index.js
+var require_dist3 = __commonJS({
+  "../../node_modules/.pnpm/path-to-regexp@6.3.0/node_modules/path-to-regexp/dist/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.pathToRegexp = exports.tokensToRegexp = exports.regexpToFunction = exports.match = exports.tokensToFunction = exports.compile = exports.parse = void 0;
+    function lexer(str) {
+      var tokens = [];
+      var i = 0;
+      while (i < str.length) {
+        var char = str[i];
+        if (char === "*" || char === "+" || char === "?") {
+          tokens.push({ type: "MODIFIER", index: i, value: str[i++] });
+          continue;
+        }
+        if (char === "\\") {
+          tokens.push({ type: "ESCAPED_CHAR", index: i++, value: str[i++] });
+          continue;
+        }
+        if (char === "{") {
+          tokens.push({ type: "OPEN", index: i, value: str[i++] });
+          continue;
+        }
+        if (char === "}") {
+          tokens.push({ type: "CLOSE", index: i, value: str[i++] });
+          continue;
+        }
+        if (char === ":") {
+          var name = "";
+          var j = i + 1;
+          while (j < str.length) {
+            var code = str.charCodeAt(j);
+            if (
+              // `0-9`
+              code >= 48 && code <= 57 || // `A-Z`
+              code >= 65 && code <= 90 || // `a-z`
+              code >= 97 && code <= 122 || // `_`
+              code === 95
+            ) {
+              name += str[j++];
+              continue;
+            }
+            break;
+          }
+          if (!name)
+            throw new TypeError("Missing parameter name at ".concat(i));
+          tokens.push({ type: "NAME", index: i, value: name });
+          i = j;
+          continue;
+        }
+        if (char === "(") {
+          var count = 1;
+          var pattern = "";
+          var j = i + 1;
+          if (str[j] === "?") {
+            throw new TypeError('Pattern cannot start with "?" at '.concat(j));
+          }
+          while (j < str.length) {
+            if (str[j] === "\\") {
+              pattern += str[j++] + str[j++];
+              continue;
+            }
+            if (str[j] === ")") {
+              count--;
+              if (count === 0) {
+                j++;
+                break;
+              }
+            } else if (str[j] === "(") {
+              count++;
+              if (str[j + 1] !== "?") {
+                throw new TypeError("Capturing groups are not allowed at ".concat(j));
+              }
+            }
+            pattern += str[j++];
+          }
+          if (count)
+            throw new TypeError("Unbalanced pattern at ".concat(i));
+          if (!pattern)
+            throw new TypeError("Missing pattern at ".concat(i));
+          tokens.push({ type: "PATTERN", index: i, value: pattern });
+          i = j;
+          continue;
+        }
+        tokens.push({ type: "CHAR", index: i, value: str[i++] });
+      }
+      tokens.push({ type: "END", index: i, value: "" });
+      return tokens;
+    }
+    function parse6(str, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var tokens = lexer(str);
+      var _a = options.prefixes, prefixes = _a === void 0 ? "./" : _a, _b = options.delimiter, delimiter = _b === void 0 ? "/#?" : _b;
+      var result = [];
+      var key = 0;
+      var i = 0;
+      var path8 = "";
+      var tryConsume = function(type) {
+        if (i < tokens.length && tokens[i].type === type)
+          return tokens[i++].value;
+      };
+      var mustConsume = function(type) {
+        var value2 = tryConsume(type);
+        if (value2 !== void 0)
+          return value2;
+        var _a2 = tokens[i], nextType = _a2.type, index = _a2.index;
+        throw new TypeError("Unexpected ".concat(nextType, " at ").concat(index, ", expected ").concat(type));
+      };
+      var consumeText = function() {
+        var result2 = "";
+        var value2;
+        while (value2 = tryConsume("CHAR") || tryConsume("ESCAPED_CHAR")) {
+          result2 += value2;
+        }
+        return result2;
+      };
+      var isSafe = function(value2) {
+        for (var _i = 0, delimiter_1 = delimiter; _i < delimiter_1.length; _i++) {
+          var char2 = delimiter_1[_i];
+          if (value2.indexOf(char2) > -1)
+            return true;
+        }
+        return false;
+      };
+      var safePattern = function(prefix2) {
+        var prev = result[result.length - 1];
+        var prevText = prefix2 || (prev && typeof prev === "string" ? prev : "");
+        if (prev && !prevText) {
+          throw new TypeError('Must have text between two parameters, missing text after "'.concat(prev.name, '"'));
+        }
+        if (!prevText || isSafe(prevText))
+          return "[^".concat(escapeString(delimiter), "]+?");
+        return "(?:(?!".concat(escapeString(prevText), ")[^").concat(escapeString(delimiter), "])+?");
+      };
+      while (i < tokens.length) {
+        var char = tryConsume("CHAR");
+        var name = tryConsume("NAME");
+        var pattern = tryConsume("PATTERN");
+        if (name || pattern) {
+          var prefix = char || "";
+          if (prefixes.indexOf(prefix) === -1) {
+            path8 += prefix;
+            prefix = "";
+          }
+          if (path8) {
+            result.push(path8);
+            path8 = "";
+          }
+          result.push({
+            name: name || key++,
+            prefix,
+            suffix: "",
+            pattern: pattern || safePattern(prefix),
+            modifier: tryConsume("MODIFIER") || ""
+          });
+          continue;
+        }
+        var value = char || tryConsume("ESCAPED_CHAR");
+        if (value) {
+          path8 += value;
+          continue;
+        }
+        if (path8) {
+          result.push(path8);
+          path8 = "";
+        }
+        var open = tryConsume("OPEN");
+        if (open) {
+          var prefix = consumeText();
+          var name_1 = tryConsume("NAME") || "";
+          var pattern_1 = tryConsume("PATTERN") || "";
+          var suffix = consumeText();
+          mustConsume("CLOSE");
+          result.push({
+            name: name_1 || (pattern_1 ? key++ : ""),
+            pattern: name_1 && !pattern_1 ? safePattern(prefix) : pattern_1,
+            prefix,
+            suffix,
+            modifier: tryConsume("MODIFIER") || ""
+          });
+          continue;
+        }
+        mustConsume("END");
+      }
+      return result;
+    }
+    exports.parse = parse6;
+    function compile(str, options) {
+      return tokensToFunction(parse6(str, options), options);
+    }
+    exports.compile = compile;
+    function tokensToFunction(tokens, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var reFlags = flags(options);
+      var _a = options.encode, encode = _a === void 0 ? function(x) {
+        return x;
+      } : _a, _b = options.validate, validate = _b === void 0 ? true : _b;
+      var matches = tokens.map(function(token) {
+        if (typeof token === "object") {
+          return new RegExp("^(?:".concat(token.pattern, ")$"), reFlags);
+        }
+      });
+      return function(data) {
+        var path8 = "";
+        for (var i = 0; i < tokens.length; i++) {
+          var token = tokens[i];
+          if (typeof token === "string") {
+            path8 += token;
+            continue;
+          }
+          var value = data ? data[token.name] : void 0;
+          var optional = token.modifier === "?" || token.modifier === "*";
+          var repeat = token.modifier === "*" || token.modifier === "+";
+          if (Array.isArray(value)) {
+            if (!repeat) {
+              throw new TypeError('Expected "'.concat(token.name, '" to not repeat, but got an array'));
+            }
+            if (value.length === 0) {
+              if (optional)
+                continue;
+              throw new TypeError('Expected "'.concat(token.name, '" to not be empty'));
+            }
+            for (var j = 0; j < value.length; j++) {
+              var segment = encode(value[j], token);
+              if (validate && !matches[i].test(segment)) {
+                throw new TypeError('Expected all "'.concat(token.name, '" to match "').concat(token.pattern, '", but got "').concat(segment, '"'));
+              }
+              path8 += token.prefix + segment + token.suffix;
+            }
+            continue;
+          }
+          if (typeof value === "string" || typeof value === "number") {
+            var segment = encode(String(value), token);
+            if (validate && !matches[i].test(segment)) {
+              throw new TypeError('Expected "'.concat(token.name, '" to match "').concat(token.pattern, '", but got "').concat(segment, '"'));
+            }
+            path8 += token.prefix + segment + token.suffix;
+            continue;
+          }
+          if (optional)
+            continue;
+          var typeOfMessage = repeat ? "an array" : "a string";
+          throw new TypeError('Expected "'.concat(token.name, '" to be ').concat(typeOfMessage));
+        }
+        return path8;
+      };
+    }
+    exports.tokensToFunction = tokensToFunction;
+    function match(str, options) {
+      var keys = [];
+      var re = pathToRegexp3(str, keys, options);
+      return regexpToFunction(re, keys, options);
+    }
+    exports.match = match;
+    function regexpToFunction(re, keys, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var _a = options.decode, decode = _a === void 0 ? function(x) {
+        return x;
+      } : _a;
+      return function(pathname) {
+        var m = re.exec(pathname);
+        if (!m)
+          return false;
+        var path8 = m[0], index = m.index;
+        var params = /* @__PURE__ */ Object.create(null);
+        var _loop_1 = function(i2) {
+          if (m[i2] === void 0)
+            return "continue";
+          var key = keys[i2 - 1];
+          if (key.modifier === "*" || key.modifier === "+") {
+            params[key.name] = m[i2].split(key.prefix + key.suffix).map(function(value) {
+              return decode(value, key);
+            });
+          } else {
+            params[key.name] = decode(m[i2], key);
+          }
+        };
+        for (var i = 1; i < m.length; i++) {
+          _loop_1(i);
+        }
+        return { path: path8, index, params };
+      };
+    }
+    exports.regexpToFunction = regexpToFunction;
+    function escapeString(str) {
+      return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+    }
+    function flags(options) {
+      return options && options.sensitive ? "" : "i";
+    }
+    function regexpToRegexp(path8, keys) {
+      if (!keys)
+        return path8;
+      var groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
+      var index = 0;
+      var execResult = groupsRegex.exec(path8.source);
+      while (execResult) {
+        keys.push({
+          // Use parenthesized substring match if available, index otherwise
+          name: execResult[1] || index++,
+          prefix: "",
+          suffix: "",
+          modifier: "",
+          pattern: ""
+        });
+        execResult = groupsRegex.exec(path8.source);
+      }
+      return path8;
+    }
+    function arrayToRegexp(paths, keys, options) {
+      var parts = paths.map(function(path8) {
+        return pathToRegexp3(path8, keys, options).source;
+      });
+      return new RegExp("(?:".concat(parts.join("|"), ")"), flags(options));
+    }
+    function stringToRegexp(path8, keys, options) {
+      return tokensToRegexp(parse6(path8, options), keys, options);
+    }
+    function tokensToRegexp(tokens, keys, options) {
+      if (options === void 0) {
+        options = {};
+      }
+      var _a = options.strict, strict = _a === void 0 ? false : _a, _b = options.start, start = _b === void 0 ? true : _b, _c = options.end, end = _c === void 0 ? true : _c, _d = options.encode, encode = _d === void 0 ? function(x) {
+        return x;
+      } : _d, _e = options.delimiter, delimiter = _e === void 0 ? "/#?" : _e, _f = options.endsWith, endsWith = _f === void 0 ? "" : _f;
+      var endsWithRe = "[".concat(escapeString(endsWith), "]|$");
+      var delimiterRe = "[".concat(escapeString(delimiter), "]");
+      var route = start ? "^" : "";
+      for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
+        var token = tokens_1[_i];
+        if (typeof token === "string") {
+          route += escapeString(encode(token));
+        } else {
+          var prefix = escapeString(encode(token.prefix));
+          var suffix = escapeString(encode(token.suffix));
+          if (token.pattern) {
+            if (keys)
+              keys.push(token);
+            if (prefix || suffix) {
+              if (token.modifier === "+" || token.modifier === "*") {
+                var mod = token.modifier === "*" ? "?" : "";
+                route += "(?:".concat(prefix, "((?:").concat(token.pattern, ")(?:").concat(suffix).concat(prefix, "(?:").concat(token.pattern, "))*)").concat(suffix, ")").concat(mod);
+              } else {
+                route += "(?:".concat(prefix, "(").concat(token.pattern, ")").concat(suffix, ")").concat(token.modifier);
+              }
+            } else {
+              if (token.modifier === "+" || token.modifier === "*") {
+                throw new TypeError('Can not repeat "'.concat(token.name, '" without a prefix and suffix'));
+              }
+              route += "(".concat(token.pattern, ")").concat(token.modifier);
+            }
+          } else {
+            route += "(?:".concat(prefix).concat(suffix, ")").concat(token.modifier);
+          }
+        }
+      }
+      if (end) {
+        if (!strict)
+          route += "".concat(delimiterRe, "?");
+        route += !options.endsWith ? "$" : "(?=".concat(endsWithRe, ")");
+      } else {
+        var endToken = tokens[tokens.length - 1];
+        var isEndDelimited = typeof endToken === "string" ? delimiterRe.indexOf(endToken[endToken.length - 1]) > -1 : endToken === void 0;
+        if (!strict) {
+          route += "(?:".concat(delimiterRe, "(?=").concat(endsWithRe, "))?");
+        }
+        if (!isEndDelimited) {
+          route += "(?=".concat(delimiterRe, "|").concat(endsWithRe, ")");
+        }
+      }
+      return new RegExp(route, flags(options));
+    }
+    exports.tokensToRegexp = tokensToRegexp;
+    function pathToRegexp3(path8, keys, options) {
+      if (path8 instanceof RegExp)
+        return regexpToRegexp(path8, keys);
+      if (Array.isArray(path8))
+        return arrayToRegexp(path8, keys, options);
+      return stringToRegexp(path8, keys, options);
+    }
+    exports.pathToRegexp = pathToRegexp3;
+  }
+});
+
+// ../routing-utils/dist/superstatic.js
+var require_superstatic = __commonJS({
+  "../routing-utils/dist/superstatic.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var superstatic_exports = {};
+    __export2(superstatic_exports, {
+      collectHasSegments: () => collectHasSegments,
+      compilePathToRegexpTemplate: () => compilePathToRegexpTemplate2,
+      convertCleanUrls: () => convertCleanUrls,
+      convertHeaders: () => convertHeaders,
+      convertRedirects: () => convertRedirects,
+      convertRewrites: () => convertRewrites2,
+      convertTrailingSlash: () => convertTrailingSlash,
+      getCleanUrls: () => getCleanUrls2,
+      pathToRegexp: () => pathToRegexp3,
+      sourceToRegex: () => sourceToRegex2
+    });
+    module2.exports = __toCommonJS2(superstatic_exports);
+    var import_url = require("url");
+    var import_path_to_regexp = require_dist2();
+    var import_path_to_regexp_updated = require_dist3();
+    function cloneKeys(keys) {
+      if (typeof keys === "undefined") {
+        return void 0;
+      }
+      return keys.slice(0);
+    }
+    function compareKeys(left, right) {
+      const leftSerialized = typeof left === "undefined" ? "undefined" : left.toString();
+      const rightSerialized = typeof right === "undefined" ? "undefined" : right.toString();
+      return leftSerialized === rightSerialized;
+    }
+    function pathToRegexp3(callerId, path8, keys, options) {
+      const newKeys = cloneKeys(keys);
+      const currentRegExp = (0, import_path_to_regexp.pathToRegexp)(path8, keys, options);
+      try {
+        const currentKeys = keys;
+        const newRegExp = (0, import_path_to_regexp_updated.pathToRegexp)(path8, newKeys, options);
+        const isDiffRegExp = currentRegExp.toString() !== newRegExp.toString();
+        if (process.env.FORCE_PATH_TO_REGEXP_LOG || isDiffRegExp) {
+          const message = JSON.stringify({
+            path: path8,
+            currentRegExp: currentRegExp.toString(),
+            newRegExp: newRegExp.toString()
+          });
+          console.error(`[vc] PATH TO REGEXP PATH DIFF @ #${callerId}: ${message}`);
+        }
+        const isDiffKeys = !compareKeys(keys, newKeys);
+        if (process.env.FORCE_PATH_TO_REGEXP_LOG || isDiffKeys) {
+          const message = JSON.stringify({
+            isDiffKeys,
+            currentKeys,
+            newKeys
+          });
+          console.error(`[vc] PATH TO REGEXP KEYS DIFF @ #${callerId}: ${message}`);
+        }
+      } catch (err) {
+        const error = err;
+        const message = JSON.stringify({
+          path: path8,
+          error: error.message
+        });
+        console.error(`[vc] PATH TO REGEXP ERROR @ #${callerId}: ${message}`);
+      }
+      return currentRegExp;
+    }
+    var UN_NAMED_SEGMENT = "__UN_NAMED_SEGMENT__";
+    function getCleanUrls2(filePaths) {
+      const htmlFiles = filePaths.map(toRoute).filter((f) => f.endsWith(".html")).map((f) => ({
+        html: f,
+        clean: f.slice(0, -5)
+      }));
+      return htmlFiles;
+    }
+    function convertCleanUrls(cleanUrls, trailingSlash, status = 308) {
+      const routes = [];
+      if (cleanUrls) {
+        const loc = trailingSlash ? "/$1/" : "/$1";
+        routes.push({
+          src: "^/(?:(.+)/)?index(?:\\.html)?/?$",
+          headers: { Location: loc },
+          status
+        });
+        routes.push({
+          src: "^/(.*)\\.html/?$",
+          headers: { Location: loc },
+          status
+        });
+      }
+      return routes;
+    }
+    function convertRedirects(redirects, defaultStatus = 308) {
+      return redirects.map((r) => {
+        const { src, segments } = sourceToRegex2(r.source);
+        const hasSegments = collectHasSegments(r.has);
+        normalizeHasKeys(r.has);
+        normalizeHasKeys(r.missing);
+        try {
+          const loc = replaceSegments(segments, hasSegments, r.destination, true);
+          let status;
+          if (typeof r.permanent === "boolean") {
+            status = r.permanent ? 308 : 307;
+          } else if (r.statusCode) {
+            status = r.statusCode;
+          } else {
+            status = defaultStatus;
+          }
+          const route = {
+            src,
+            headers: { Location: loc },
+            status
+          };
+          if (typeof r.env !== "undefined") {
+            route.env = r.env;
+          }
+          if (r.has) {
+            route.has = r.has;
+          }
+          if (r.missing) {
+            route.missing = r.missing;
+          }
+          return route;
+        } catch (_e) {
+          throw new Error(`Failed to parse redirect: ${JSON.stringify(r)}`);
+        }
+      });
+    }
+    function convertRewrites2(rewrites, internalParamNames) {
+      return rewrites.map((r) => {
+        const { src, segments } = sourceToRegex2(r.source);
+        const hasSegments = collectHasSegments(r.has);
+        normalizeHasKeys(r.has);
+        normalizeHasKeys(r.missing);
+        try {
+          const interpolate = (value) => replaceSegments(
+            segments,
+            hasSegments,
+            value,
+            false,
+            internalParamNames
+          );
+          let route;
+          if (typeof r.destination === "string") {
+            route = { src, dest: interpolate(r.destination), check: true };
+          } else {
+            const destination = { ...r.destination, type: "service" };
+            if (typeof destination.path === "string") {
+              destination.path = interpolate(destination.path);
+            }
+            route = { src, destination };
+          }
+          if (r.transforms) {
+            route.transforms = r.transforms.map((transform) => {
+              if (transform.type !== "request.path") {
+                return { ...transform };
+              }
+              return {
+                ...transform,
+                args: compilePathToRegexpTemplateFromSegments(
+                  transform.args,
+                  segments,
+                  hasSegments,
+                  transform.env
+                )
+              };
+            });
+          }
+          if (typeof r.env !== "undefined") {
+            route.env = r.env;
+          }
+          if (r.has) {
+            route.has = r.has;
+          }
+          if (r.missing) {
+            route.missing = r.missing;
+          }
+          if (r.statusCode) {
+            route.status = r.statusCode;
+          }
+          return route;
+        } catch (_e) {
+          throw new Error(`Failed to parse rewrite: ${JSON.stringify(r)}`);
+        }
+      });
+    }
+    function convertHeaders(headers) {
+      return headers.map((h) => {
+        const obj = {};
+        const { src, segments } = sourceToRegex2(h.source);
+        const hasSegments = collectHasSegments(h.has);
+        normalizeHasKeys(h.has);
+        normalizeHasKeys(h.missing);
+        const namedSegments = segments.filter((name) => name !== UN_NAMED_SEGMENT);
+        const indexes = {};
+        segments.forEach((name, index) => {
+          indexes[name] = toSegmentDest(index);
+        });
+        hasSegments.forEach((name) => {
+          indexes[name] = "$" + name;
+        });
+        h.headers.forEach(({ key, value }) => {
+          if (namedSegments.length > 0 || hasSegments.length > 0) {
+            if (key.includes(":")) {
+              key = safelyCompile(key, indexes);
+            }
+            if (value.includes(":")) {
+              value = safelyCompile(value, indexes);
+            }
+          }
+          obj[key] = value;
+        });
+        const route = {
+          src,
+          headers: obj,
+          continue: true
+        };
+        if (h.has) {
+          route.has = h.has;
+        }
+        if (h.missing) {
+          route.missing = h.missing;
+        }
+        return route;
+      });
+    }
+    function convertTrailingSlash(enable, status = 308) {
+      const routes = [];
+      if (enable) {
+        routes.push({
+          src: "^/\\.well-known(?:/.*)?$"
+        });
+        routes.push({
+          src: "^/((?:[^/]+/)*[^/\\.]+)$",
+          headers: { Location: "/$1/" },
+          status
+        });
+        routes.push({
+          src: "^/((?:[^/]+/)*[^/]+\\.\\w+)/$",
+          headers: { Location: "/$1" },
+          status
+        });
+      } else {
+        routes.push({
+          src: "^/(.*)\\/$",
+          headers: { Location: "/$1" },
+          status
+        });
+      }
+      return routes;
+    }
+    function sourceToRegex2(source) {
+      const keys = [];
+      const r = pathToRegexp3("632", source, keys, {
+        strict: true,
+        sensitive: true,
+        delimiter: "/"
+      });
+      const segments = keys.map((k) => k.name).map((name) => {
+        if (typeof name !== "string") {
+          return UN_NAMED_SEGMENT;
+        }
+        return name;
+      });
+      return { src: r.source, segments };
+    }
+    var namedGroupsRegex = /\(\?<([a-zA-Z][a-zA-Z0-9_]*)>/g;
+    var normalizeHasKeys = (hasItems = []) => {
+      for (const hasItem of hasItems) {
+        if ("key" in hasItem && hasItem.type === "header") {
+          hasItem.key = hasItem.key.toLowerCase();
+        }
+      }
+      return hasItems;
+    };
+    function getStringValueForRegex(value) {
+      if (typeof value === "string") {
+        return value;
+      }
+      if (value && typeof value === "object" && value !== null) {
+        if ("re" in value && typeof value.re === "string") {
+          return value.re;
+        }
+      }
+      return null;
+    }
+    function collectHasSegments(has) {
+      const hasSegments = /* @__PURE__ */ new Set();
+      for (const hasItem of has || []) {
+        if (!hasItem.value && "key" in hasItem) {
+          hasSegments.add(hasItem.key);
+        }
+        const stringValue = getStringValueForRegex(hasItem.value);
+        if (stringValue) {
+          for (const match of stringValue.matchAll(namedGroupsRegex)) {
+            if (match[1]) {
+              hasSegments.add(match[1]);
+            }
+          }
+          if (hasItem.type === "host") {
+            hasSegments.add("host");
+          }
+        }
+      }
+      return [...hasSegments];
+    }
+    var escapeSegment = (str, segmentName) => str.replace(new RegExp(`:${segmentName}`, "g"), `__ESC_COLON_${segmentName}`);
+    var unescapeSegments = (str) => str.replace(/__ESC_COLON_/gi, ":");
+    var pathTemplateSegmentNameRegex = /^([a-zA-Z_][a-zA-Z0-9_]*)/;
+    function isEscaped2(value, index) {
+      let backslashCount = 0;
+      for (let i = index - 1; i >= 0 && value[i] === "\\"; i--) {
+        backslashCount++;
+      }
+      return backslashCount % 2 === 1;
+    }
+    function collectPathTemplateSegments(template) {
+      const segments = [];
+      for (let i = 0; i < template.length; i++) {
+        if (template[i] !== ":" || isEscaped2(template, i)) {
+          continue;
+        }
+        const match = template.slice(i + 1).match(pathTemplateSegmentNameRegex);
+        if (match) {
+          segments.push(match[1]);
+          i += match[1].length;
+        }
+      }
+      return segments;
+    }
+    function collectNamedDollarReferences(template) {
+      const references = [];
+      for (let i = 0; i < template.length; i++) {
+        if (template[i] !== "$" || isEscaped2(template, i)) {
+          continue;
+        }
+        const remainder = template.slice(i + 1);
+        const bracedMatch = remainder.match(/^\{([a-zA-Z_][a-zA-Z0-9_]*)\}/);
+        const unbracedMatch = remainder.match(pathTemplateSegmentNameRegex);
+        const name = bracedMatch?.[1] || unbracedMatch?.[1];
+        if (name) {
+          references.push(name);
+        }
+      }
+      return references;
+    }
+    function compilePathToRegexpTemplateFromSegments(template, segments, hasItemSegments, env = []) {
+      const indexes = {};
+      segments.forEach((name, index) => {
+        indexes[name] = toSegmentDest(index);
+      });
+      hasItemSegments.forEach((name) => {
+        indexes[name] = `$${name}`;
+      });
+      for (const name of collectPathTemplateSegments(template)) {
+        if (!(name in indexes)) {
+          throw new Error(
+            `Path template references parameter ":${name}" that is not present in the source or has conditions.`
+          );
+        }
+      }
+      const routeParameters = /* @__PURE__ */ new Set([
+        ...segments.filter((name) => name !== UN_NAMED_SEGMENT),
+        ...hasItemSegments
+      ]);
+      for (const name of collectNamedDollarReferences(template)) {
+        if (routeParameters.has(name) && !env.includes(name)) {
+          throw new Error(
+            `Path template references route parameter "${name}" as \`$${name}\`. Use \`:${name}\` path-to-regexp syntax in high-level rewrites, or list "${name}" in the transform env allowlist if it is an environment variable.`
+          );
+        }
+      }
+      return safelyCompile(template, indexes, true);
+    }
+    function compilePathToRegexpTemplate2(source, template, has, env) {
+      const { segments } = sourceToRegex2(source);
+      return compilePathToRegexpTemplateFromSegments(
+        template,
+        segments,
+        collectHasSegments(has),
+        env
+      );
+    }
+    function replaceSegments(segments, hasItemSegments, destination, isRedirect, internalParamNames) {
+      const namedSegments = segments.filter((name) => name !== UN_NAMED_SEGMENT);
+      const canNeedReplacing = destination.includes(":") && namedSegments.length > 0 || hasItemSegments.length > 0 || !isRedirect;
+      if (!canNeedReplacing) {
+        return destination;
+      }
+      let escapedDestination = destination;
+      const indexes = {};
+      segments.forEach((name, index) => {
+        indexes[name] = toSegmentDest(index);
+        escapedDestination = escapeSegment(escapedDestination, name);
+      });
+      hasItemSegments.forEach((name) => {
+        indexes[name] = "$" + name;
+        escapedDestination = escapeSegment(escapedDestination, name);
+      });
+      const parsedDestination = (0, import_url.parse)(escapedDestination, true);
+      delete parsedDestination.href;
+      delete parsedDestination.path;
+      delete parsedDestination.search;
+      delete parsedDestination.host;
+      let { pathname, hash, query, hostname, ...rest } = parsedDestination;
+      pathname = unescapeSegments(pathname || "");
+      hash = unescapeSegments(hash || "");
+      hostname = unescapeSegments(hostname || "");
+      let destParams = /* @__PURE__ */ new Set();
+      const pathnameKeys = [];
+      const hashKeys = [];
+      const hostnameKeys = [];
+      try {
+        pathToRegexp3("528", pathname, pathnameKeys);
+        pathToRegexp3("834", hash || "", hashKeys);
+        pathToRegexp3("712", hostname || "", hostnameKeys);
+      } catch (_) {
+      }
+      destParams = new Set(
+        [...pathnameKeys, ...hashKeys, ...hostnameKeys].map((key) => key.name).filter((val) => typeof val === "string")
+      );
+      pathname = safelyCompile(pathname, indexes, true);
+      hash = hash ? safelyCompile(hash, indexes, true) : null;
+      hostname = hostname ? safelyCompile(hostname, indexes, true) : null;
+      for (const [key, strOrArray] of Object.entries(query)) {
+        if (Array.isArray(strOrArray)) {
+          query[key] = strOrArray.map(
+            (str) => safelyCompile(unescapeSegments(str), indexes, true)
+          );
+        } else {
+          query[key] = safelyCompile(
+            unescapeSegments(strOrArray),
+            indexes,
+            true
+          );
+        }
+      }
+      const paramKeys = Object.keys(indexes);
+      const needsQueryUpdating = (
+        // we do not consider an internal param since it is added automatically
+        !isRedirect && !paramKeys.some(
+          (param) => !(internalParamNames && internalParamNames.includes(param)) && destParams.has(param)
+        )
+      );
+      if (needsQueryUpdating) {
+        for (const param of paramKeys) {
+          if (!(param in query) && param !== UN_NAMED_SEGMENT) {
+            query[param] = indexes[param];
+          }
+        }
+      }
+      destination = (0, import_url.format)({
+        ...rest,
+        hostname,
+        pathname,
+        query,
+        hash
+      });
+      return destination.replace(/%24/g, "$");
+    }
+    function safelyCompile(value, indexes, attemptDirectCompile) {
+      if (!value) {
+        return value;
+      }
+      if (attemptDirectCompile) {
+        try {
+          return (0, import_path_to_regexp.compile)(value, { validate: false })(indexes);
+        } catch (_e) {
+        }
+      }
+      for (const key of Object.keys(indexes)) {
+        if (value.includes(`:${key}`)) {
+          value = value.replace(
+            new RegExp(`:${key}\\*`, "g"),
+            `:${key}--ESCAPED_PARAM_ASTERISK`
+          ).replace(
+            new RegExp(`:${key}\\?`, "g"),
+            `:${key}--ESCAPED_PARAM_QUESTION`
+          ).replace(new RegExp(`:${key}\\+`, "g"), `:${key}--ESCAPED_PARAM_PLUS`).replace(
+            new RegExp(`:${key}(?!\\w)`, "g"),
+            `--ESCAPED_PARAM_COLON${key}`
+          );
+        }
+      }
+      value = value.replace(/(:|\*|\?|\+|\(|\)|\{|\})/g, "\\$1").replace(/--ESCAPED_PARAM_PLUS/g, "+").replace(/--ESCAPED_PARAM_COLON/g, ":").replace(/--ESCAPED_PARAM_QUESTION/g, "?").replace(/--ESCAPED_PARAM_ASTERISK/g, "*");
+      return (0, import_path_to_regexp.compile)(`/${value}`, { validate: false })(indexes).slice(1);
+    }
+    function toSegmentDest(index) {
+      const i = index + 1;
+      return "$" + i.toString();
+    }
+    function toRoute(filePath) {
+      return filePath.startsWith("/") ? filePath : "/" + filePath;
+    }
+  }
+});
+
+// ../routing-utils/dist/append.js
+var require_append = __commonJS({
+  "../routing-utils/dist/append.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var append_exports = {};
+    __export2(append_exports, {
+      appendRoutesToPhase: () => appendRoutesToPhase2
+    });
+    module2.exports = __toCommonJS2(append_exports);
+    var import_index = require_dist4();
+    function appendRoutesToPhase2({
+      routes: prevRoutes,
+      newRoutes,
+      phase
+    }) {
+      const routes = prevRoutes ? [...prevRoutes] : [];
+      if (newRoutes === null || newRoutes.length === 0) {
+        return routes;
+      }
+      let isInPhase = false;
+      let insertIndex = -1;
+      routes.forEach((r, i) => {
+        if ((0, import_index.isHandler)(r)) {
+          if (r.handle === phase) {
+            isInPhase = true;
+          } else if (isInPhase) {
+            insertIndex = i;
+            isInPhase = false;
+          }
+        }
+      });
+      if (isInPhase) {
+        routes.push(...newRoutes);
+      } else if (phase === null) {
+        const lastPhase = routes.findIndex((r) => (0, import_index.isHandler)(r) && r.handle);
+        if (lastPhase === -1) {
+          routes.push(...newRoutes);
+        } else {
+          routes.splice(lastPhase, 0, ...newRoutes);
+        }
+      } else if (insertIndex > -1) {
+        routes.splice(insertIndex, 0, ...newRoutes);
+      } else {
+        routes.push({ handle: phase });
+        routes.push(...newRoutes);
+      }
+      return routes;
+    }
+  }
+});
+
+// ../routing-utils/dist/merge.js
+var require_merge2 = __commonJS({
+  "../routing-utils/dist/merge.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var merge_exports = {};
+    __export2(merge_exports, {
+      mergeRoutes: () => mergeRoutes2
+    });
+    module2.exports = __toCommonJS2(merge_exports);
+    var import_index = require_dist4();
+    function getBuilderRoutesMapping(builds) {
+      const builderRoutes = {};
+      for (const { entrypoint, routes, use } of builds) {
+        if (routes) {
+          if (!builderRoutes[entrypoint]) {
+            builderRoutes[entrypoint] = {};
+          }
+          builderRoutes[entrypoint][use] = routes;
+        }
+      }
+      return builderRoutes;
+    }
+    function getCheckAndContinue(routes) {
+      const checks = [];
+      const continues = [];
+      const others = [];
+      for (const route of routes) {
+        if ((0, import_index.isHandler)(route)) {
+          throw new Error(
+            `Unexpected route found in getCheckAndContinue(): ${JSON.stringify(
+              route
+            )}`
+          );
+        } else if (route.check && !route.override) {
+          checks.push(route);
+        } else if (route.continue && !route.override) {
+          continues.push(route);
+        } else {
+          others.push(route);
+        }
+      }
+      return { checks, continues, others };
+    }
+    function mergeRoutes2({ userRoutes, builds }) {
+      const userHandleMap = /* @__PURE__ */ new Map();
+      let userPrevHandle = null;
+      (userRoutes || []).forEach((route) => {
+        if ((0, import_index.isHandler)(route)) {
+          userPrevHandle = route.handle;
+        } else {
+          const routes = userHandleMap.get(userPrevHandle);
+          if (!routes) {
+            userHandleMap.set(userPrevHandle, [route]);
+          } else {
+            routes.push(route);
+          }
+        }
+      });
+      const builderHandleMap = /* @__PURE__ */ new Map();
+      const builderRoutes = getBuilderRoutesMapping(builds);
+      const sortedPaths = Object.keys(builderRoutes).sort();
+      sortedPaths.forEach((path8) => {
+        const br = builderRoutes[path8];
+        const sortedBuilders = Object.keys(br).sort();
+        sortedBuilders.forEach((use) => {
+          let builderPrevHandle = null;
+          br[use].forEach((route) => {
+            if ((0, import_index.isHandler)(route)) {
+              builderPrevHandle = route.handle;
+            } else {
+              const routes = builderHandleMap.get(builderPrevHandle);
+              if (!routes) {
+                builderHandleMap.set(builderPrevHandle, [route]);
+              } else {
+                routes.push(route);
+              }
+            }
+          });
+        });
+      });
+      const outputRoutes = [];
+      const uniqueHandleValues = /* @__PURE__ */ new Set([
+        null,
+        ...userHandleMap.keys(),
+        ...builderHandleMap.keys()
+      ]);
+      for (const handle of uniqueHandleValues) {
+        const userRoutes2 = userHandleMap.get(handle) || [];
+        const builderRoutes2 = builderHandleMap.get(handle) || [];
+        const builderSorted = getCheckAndContinue(builderRoutes2);
+        if (handle !== null && (userRoutes2.length > 0 || builderRoutes2.length > 0)) {
+          outputRoutes.push({ handle });
+        }
+        outputRoutes.push(...builderSorted.continues);
+        outputRoutes.push(...userRoutes2);
+        outputRoutes.push(...builderSorted.checks);
+        outputRoutes.push(...builderSorted.others);
+      }
+      return outputRoutes;
+    }
+  }
+});
+
+// ../routing-utils/dist/service-route-ownership.js
+var require_service_route_ownership = __commonJS({
+  "../routing-utils/dist/service-route-ownership.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var service_route_ownership_exports = {};
+    __export2(service_route_ownership_exports, {
+      getOwnershipGuard: () => getOwnershipGuard2,
+      normalizeRoutePrefix: () => normalizeRoutePrefix2,
+      scopeRouteSourceToOwnership: () => scopeRouteSourceToOwnership2
+    });
+    module2.exports = __toCommonJS2(service_route_ownership_exports);
+    function normalizeRoutePrefix2(routePrefix) {
+      let normalized = routePrefix.startsWith("/") ? routePrefix : `/${routePrefix}`;
+      if (normalized !== "/" && normalized.endsWith("/")) {
+        normalized = normalized.slice(0, -1);
+      }
+      return normalized || "/";
+    }
+    function escapeForRegex(value) {
+      return value.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&");
+    }
+    function toPrefixMatcher(routePrefix) {
+      return `${escapeForRegex(routePrefix)}(?:/|$)`;
+    }
+    function isDescendantPrefix(candidate, prefix) {
+      return candidate !== prefix && candidate.startsWith(`${prefix}/`);
+    }
+    function getOwnershipGuard2(ownerPrefix, allRoutePrefixes) {
+      const owner = normalizeRoutePrefix2(ownerPrefix);
+      const normalizedPrefixes = Array.from(
+        new Set(allRoutePrefixes.map(normalizeRoutePrefix2))
+      );
+      const nonRootPrefixes = normalizedPrefixes.filter((prefix) => prefix !== "/").sort((a, b) => b.length - a.length);
+      if (owner === "/") {
+        return nonRootPrefixes.map((prefix) => `(?!${toPrefixMatcher(prefix)})`).join("");
+      }
+      const descendants = nonRootPrefixes.filter(
+        (prefix) => isDescendantPrefix(prefix, owner)
+      );
+      const positive = `(?=${toPrefixMatcher(owner)})`;
+      const negative = descendants.map((prefix) => `(?!${toPrefixMatcher(prefix)})`).join("");
+      return `${positive}${negative}`;
+    }
+    function scopeRouteSourceToOwnership2(source, ownershipGuard) {
+      if (!ownershipGuard) {
+        return source;
+      }
+      const inner = source.startsWith("^") ? source.slice(1) : source;
+      return `^${ownershipGuard}(?:${inner})`;
+    }
+  }
+});
+
+// ../routing-utils/dist/schemas.js
+var require_schemas = __commonJS({
+  "../routing-utils/dist/schemas.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var schemas_exports = {};
+    __export2(schemas_exports, {
+      cleanUrlsSchema: () => cleanUrlsSchema,
+      hasSchema: () => hasSchema,
+      headersSchema: () => headersSchema,
+      redirectsSchema: () => redirectsSchema,
+      rewritesSchema: () => rewritesSchema,
+      routesSchema: () => routesSchema,
+      trailingSlashSchema: () => trailingSlashSchema,
+      transformsSchema: () => transformsSchema
+    });
+    module2.exports = __toCommonJS2(schemas_exports);
+    var mitigateSchema = {
+      description: "Mitigation action to take on a route",
+      type: "object",
+      additionalProperties: false,
+      required: ["action"],
+      properties: {
+        action: {
+          description: "The mitigation action to take",
+          type: "string",
+          enum: ["challenge", "deny"]
+        }
+      }
+    };
+    var serviceNameSchema = {
+      description: "A service name identifier.",
+      type: "string",
+      minLength: 1,
+      maxLength: 64,
+      pattern: "^[a-zA-Z]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$"
+    };
+    var serviceDestinationSchema = {
+      description: "A service-targeted destination that delegates routing into a named service from `services`. Identified by the presence of `service`.",
+      type: "object",
+      additionalProperties: false,
+      required: ["service"],
+      properties: {
+        type: {
+          description: "Optional explicit format marker. The destination shape is identified by the `service` property, so `type` is no longer required. When present it must be `service`.",
+          type: "string",
+          enum: ["service"]
+        },
+        service: serviceNameSchema,
+        path: {
+          description: "Routing-only path used to select a route inside the target service. It does not mutate the URL observed by user code.",
+          type: "string",
+          maxLength: 4096
+        }
+      }
+    };
+    var matchableValueSchema = {
+      description: "A value to match against. Can be a string (regex) or a condition operation object",
+      anyOf: [
+        {
+          description: "A regular expression used to match thev value. Named groups can be used in the destination.",
+          type: "string",
+          maxLength: 4096
+        },
+        {
+          description: "A condition operation object",
+          type: "object",
+          additionalProperties: false,
+          minProperties: 1,
+          properties: {
+            eq: {
+              description: "Equal to",
+              anyOf: [
+                {
+                  type: "string",
+                  maxLength: 4096
+                },
+                {
+                  type: "number"
+                }
+              ]
+            },
+            neq: {
+              description: "Not equal",
+              type: "string",
+              maxLength: 4096
+            },
+            inc: {
+              description: "In array",
+              type: "array",
+              items: {
+                type: "string",
+                maxLength: 4096
+              }
+            },
+            ninc: {
+              description: "Not in array",
+              type: "array",
+              items: {
+                type: "string",
+                maxLength: 4096
+              }
+            },
+            pre: {
+              description: "Starts with",
+              type: "string",
+              maxLength: 4096
+            },
+            suf: {
+              description: "Ends with",
+              type: "string",
+              maxLength: 4096
+            },
+            re: {
+              description: "Regex",
+              type: "string",
+              maxLength: 4096
+            },
+            gt: {
+              description: "Greater than",
+              type: "number"
+            },
+            gte: {
+              description: "Greater than or equal to",
+              type: "number"
+            },
+            lt: {
+              description: "Less than",
+              type: "number"
+            },
+            lte: {
+              description: "Less than or equal to",
+              type: "number"
+            }
+          }
+        }
+      ]
+    };
+    var hasSchema = {
+      description: "An array of requirements that are needed to match",
+      type: "array",
+      maxItems: 16,
+      items: {
+        anyOf: [
+          {
+            type: "object",
+            additionalProperties: false,
+            required: ["type", "value"],
+            properties: {
+              type: {
+                description: "The type of request element to check",
+                type: "string",
+                enum: ["host"]
+              },
+              value: matchableValueSchema
+            }
+          },
+          {
+            type: "object",
+            additionalProperties: false,
+            required: ["type", "key"],
+            properties: {
+              type: {
+                description: "The type of request element to check",
+                type: "string",
+                enum: ["header", "cookie", "query"]
+              },
+              key: {
+                description: "The name of the element contained in the particular type",
+                type: "string",
+                maxLength: 4096
+              },
+              value: matchableValueSchema
+            }
+          }
+        ]
+      }
+    };
+    var transformsSchema = {
+      description: "A list of transform rules to adjust a request path, request query parameters, or request/response headers",
+      type: "array",
+      minItems: 1,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["type", "op"],
+        properties: {
+          type: {
+            description: "The scope of the transform to apply",
+            type: "string",
+            enum: [
+              "request.headers",
+              "request.query",
+              "response.headers",
+              "request.path"
+            ]
+          },
+          op: {
+            description: "The operation to perform on the target",
+            type: "string",
+            enum: ["append", "set", "delete"]
+          },
+          target: {
+            description: "The target of the transform",
+            type: "object",
+            required: ["key"],
+            properties: {
+              // re is not supported for transforms. Once supported, replace target.key with matchableValueSchema
+              key: {
+                description: "A value to match against. Can be a string or a condition operation object (without regex support)",
+                anyOf: [
+                  {
+                    description: "A valid header name (letters, numbers, hyphens, underscores)",
+                    type: "string",
+                    maxLength: 4096
+                  },
+                  {
+                    description: "A condition operation object",
+                    type: "object",
+                    additionalProperties: false,
+                    minProperties: 1,
+                    properties: {
+                      eq: {
+                        description: "Equal to",
+                        anyOf: [
+                          {
+                            type: "string",
+                            maxLength: 4096
+                          },
+                          {
+                            type: "number"
+                          }
+                        ]
+                      },
+                      neq: {
+                        description: "Not equal",
+                        type: "string",
+                        maxLength: 4096
+                      },
+                      inc: {
+                        description: "In array",
+                        type: "array",
+                        items: {
+                          type: "string",
+                          maxLength: 4096
+                        }
+                      },
+                      ninc: {
+                        description: "Not in array",
+                        type: "array",
+                        items: {
+                          type: "string",
+                          maxLength: 4096
+                        }
+                      },
+                      pre: {
+                        description: "Starts with",
+                        type: "string",
+                        maxLength: 4096
+                      },
+                      suf: {
+                        description: "Ends with",
+                        type: "string",
+                        maxLength: 4096
+                      },
+                      gt: {
+                        description: "Greater than",
+                        type: "number"
+                      },
+                      gte: {
+                        description: "Greater than or equal to",
+                        type: "number"
+                      },
+                      lt: {
+                        description: "Less than",
+                        type: "number"
+                      },
+                      lte: {
+                        description: "Less than or equal to",
+                        type: "number"
+                      }
+                    }
+                  }
+                ]
+              }
+            }
+          },
+          args: {
+            description: "The arguments to the operation",
+            anyOf: [
+              {
+                type: "string",
+                maxLength: 4096
+              },
+              {
+                type: "array",
+                minItems: 1,
+                items: {
+                  type: "string",
+                  maxLength: 4096
+                }
+              }
+            ]
+          },
+          env: {
+            description: "An array of environment variable names that should be replaced at runtime in the args value",
+            type: "array",
+            minItems: 1,
+            maxItems: 64,
+            items: {
+              type: "string",
+              maxLength: 256
+            }
+          }
+        },
+        allOf: [
+          {
+            if: {
+              properties: {
+                op: {
+                  enum: ["append", "set"]
+                }
+              }
+            },
+            // biome-ignore lint/suspicious/noThenProperty: JSON Schema if/then keyword
+            then: {
+              required: ["args"]
+            }
+          },
+          {
+            if: {
+              allOf: [
+                {
+                  properties: {
+                    type: {
+                      enum: ["request.headers", "response.headers"]
+                    }
+                  }
+                },
+                {
+                  properties: {
+                    op: {
+                      enum: ["set", "append"]
+                    }
+                  }
+                }
+              ]
+            },
+            // biome-ignore lint/suspicious/noThenProperty: JSON Schema if/then keyword
+            then: {
+              properties: {
+                target: {
+                  properties: {
+                    key: {
+                      if: {
+                        type: "string"
+                      },
+                      // biome-ignore lint/suspicious/noThenProperty: JSON Schema if/then keyword
+                      then: {
+                        pattern: "^[a-zA-Z0-9_-]+$"
+                      }
+                    }
+                  }
+                },
+                args: {
+                  anyOf: [
+                    {
+                      type: "string",
+                      pattern: "^[a-zA-Z0-9_ :;.,\"'?!(){}\\[\\]@<>=+*#$&`|~\\^%/-]+$"
+                    },
+                    {
+                      type: "array",
+                      items: {
+                        type: "string",
+                        pattern: "^[a-zA-Z0-9_ :;.,\"'?!(){}\\[\\]@<>=+*#$&`|~\\^%/-]+$"
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          {
+            if: {
+              required: ["type"],
+              properties: {
+                type: {
+                  enum: ["request.headers", "request.query", "response.headers"]
+                }
+              }
+            },
+            // biome-ignore lint/suspicious/noThenProperty: JSON Schema if/then keyword
+            then: {
+              required: ["target"]
+            }
+          },
+          {
+            if: {
+              required: ["type"],
+              properties: {
+                type: {
+                  enum: ["request.path"]
+                }
+              }
+            },
+            // biome-ignore lint/suspicious/noThenProperty: JSON Schema if/then keyword
+            then: {
+              required: ["args"],
+              not: {
+                required: ["target"]
+              },
+              properties: {
+                op: {
+                  enum: ["set"]
+                },
+                args: {
+                  description: "The runtime-visible request path. Must be an origin-form path without query or fragment.",
+                  type: "string",
+                  maxLength: 2048,
+                  pattern: "^/(?!/)(?!.*[?#\\s\\x00-\\x1F\\x7F]).*$"
+                }
+              }
+            }
+          }
+        ]
+      }
+    };
+    var rewriteTransformsSchema = {
+      description: "A list of request path transforms using path-to-regexp parameters.",
+      type: "array",
+      minItems: 1,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["type", "op", "args"],
+        properties: {
+          type: {
+            description: "The request path to expose to the target runtime",
+            type: "string",
+            enum: ["request.path"]
+          },
+          op: {
+            description: "Replace the runtime-visible request path",
+            type: "string",
+            enum: ["set"]
+          },
+          args: {
+            description: "An origin-form request path. Route parameters use path-to-regexp syntax such as `/:path*`.",
+            type: "string",
+            maxLength: 2048,
+            pattern: "^/(?!/)(?!.*[?#\\s\\x00-\\x1F\\x7F]).*$"
+          },
+          env: {
+            description: "An array of environment variable names that should be replaced at runtime in the args value",
+            type: "array",
+            minItems: 1,
+            maxItems: 64,
+            items: {
+              type: "string",
+              maxLength: 256
+            }
+          }
+        }
+      }
+    };
+    var routesSchema = {
+      type: "array",
+      description: "A list of routes objects used to rewrite paths to point towards other internal or external paths",
+      example: [{ dest: "https://docs.example.com", src: "/docs" }],
+      items: {
+        anyOf: [
+          {
+            type: "object",
+            anyOf: [{ required: ["src"] }, { required: ["source"] }],
+            additionalProperties: false,
+            properties: {
+              src: {
+                type: "string",
+                maxLength: 4096
+              },
+              source: {
+                type: "string",
+                maxLength: 4096
+              },
+              dest: {
+                type: "string",
+                maxLength: 4096
+              },
+              destination: {
+                anyOf: [
+                  { type: "string", maxLength: 4096 },
+                  serviceDestinationSchema
+                ]
+              },
+              headers: {
+                type: "object",
+                additionalProperties: false,
+                minProperties: 1,
+                maxProperties: 100,
+                patternProperties: {
+                  "^.{1,256}$": {
+                    type: "string",
+                    maxLength: 32768
+                  }
+                }
+              },
+              methods: {
+                type: "array",
+                maxItems: 10,
+                items: {
+                  type: "string",
+                  maxLength: 32
+                }
+              },
+              caseSensitive: {
+                type: "boolean"
+              },
+              important: {
+                deprecated: true,
+                type: "boolean"
+              },
+              user: {
+                type: "boolean"
+              },
+              continue: {
+                type: "boolean"
+              },
+              override: {
+                deprecated: true,
+                type: "boolean"
+              },
+              check: {
+                type: "boolean"
+              },
+              isInternal: {
+                type: "boolean"
+              },
+              status: {
+                type: "integer",
+                minimum: 100,
+                maximum: 999
+              },
+              statusCode: {
+                type: "integer",
+                minimum: 100,
+                maximum: 999
+              },
+              locale: {
+                type: "object",
+                additionalProperties: false,
+                minProperties: 1,
+                properties: {
+                  redirect: {
+                    type: "object",
+                    additionalProperties: false,
+                    minProperties: 1,
+                    maxProperties: 100,
+                    patternProperties: {
+                      "^.{1,256}$": {
+                        type: "string",
+                        maxLength: 4096
+                      }
+                    }
+                  },
+                  value: {
+                    type: "string",
+                    maxLength: 4096
+                  },
+                  path: {
+                    type: "string",
+                    maxLength: 4096
+                  },
+                  cookie: {
+                    type: "string",
+                    maxLength: 4096
+                  },
+                  default: {
+                    type: "string",
+                    maxLength: 4096
+                  }
+                }
+              },
+              middleware: { type: "number" },
+              middlewarePath: { type: "string" },
+              middlewareRawSrc: {
+                type: "array",
+                items: {
+                  type: "string"
+                }
+              },
+              has: hasSchema,
+              missing: hasSchema,
+              mitigate: mitigateSchema,
+              transforms: transformsSchema,
+              env: {
+                description: "An array of environment variable names that should be replaced at runtime in the destination or headers",
+                type: "array",
+                minItems: 1,
+                maxItems: 64,
+                items: {
+                  type: "string",
+                  maxLength: 256
+                }
+              },
+              respectOriginCacheControl: {
+                description: "When set to true (default), external rewrites will respect the Cache-Control header from the origin. When false, caching is disabled for this rewrite.",
+                type: "boolean"
+              }
+            }
+          },
+          {
+            type: "object",
+            deprecated: true,
+            required: ["handle"],
+            additionalProperties: false,
+            properties: {
+              handle: {
+                type: "string",
+                maxLength: 32,
+                enum: ["error", "filesystem", "hit", "miss", "resource", "rewrite"]
+              }
+            }
+          }
+        ]
+      }
+    };
+    var rewritesSchema = {
+      type: "array",
+      maxItems: 2048,
+      description: "A list of rewrite definitions.",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["source", "destination"],
+        properties: {
+          source: {
+            description: "A pattern that matches each incoming pathname (excluding querystring).",
+            type: "string",
+            maxLength: 4096
+          },
+          destination: {
+            description: "An absolute pathname to an existing resource, an external URL, or a service-targeted destination object.",
+            anyOf: [{ type: "string", maxLength: 4096 }, serviceDestinationSchema]
+          },
+          transforms: rewriteTransformsSchema,
+          has: hasSchema,
+          missing: hasSchema,
+          statusCode: {
+            description: "An optional integer to override the status code of the response.",
+            type: "integer",
+            minimum: 100,
+            maximum: 999
+          },
+          env: {
+            description: "An array of environment variable names that should be replaced at runtime in the destination",
+            type: "array",
+            minItems: 1,
+            maxItems: 64,
+            items: {
+              type: "string",
+              maxLength: 256
+            }
+          },
+          respectOriginCacheControl: {
+            description: "When set to true (default), external rewrites will respect the Cache-Control header from the origin. When false, caching is disabled for this rewrite.",
+            type: "boolean"
+          }
+        }
+      }
+    };
+    var redirectsSchema = {
+      title: "Redirects",
+      type: "array",
+      maxItems: 2048,
+      description: "A list of redirect definitions.",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["source", "destination"],
+        properties: {
+          source: {
+            description: "A pattern that matches each incoming pathname (excluding querystring) or a full URL including domain.",
+            type: "string",
+            maxLength: 4096
+          },
+          destination: {
+            description: "A location destination defined as an absolute pathname or external URL.",
+            type: "string",
+            maxLength: 4096
+          },
+          permanent: {
+            description: "A boolean to toggle between permanent and temporary redirect. When `true`, the status code is `308`. When `false` the status code is `307`.",
+            type: "boolean"
+          },
+          statusCode: {
+            description: "An optional integer to define the status code of the redirect.",
+            private: true,
+            type: "integer",
+            minimum: 100,
+            maximum: 999
+          },
+          has: hasSchema,
+          missing: hasSchema,
+          env: {
+            description: "An array of environment variable names that should be replaced at runtime in the destination",
+            type: "array",
+            minItems: 1,
+            maxItems: 64,
+            items: {
+              type: "string",
+              maxLength: 256
+            }
+          }
+        }
+      }
+    };
+    var headersSchema = {
+      type: "array",
+      maxItems: 2048,
+      description: "A list of header definitions.",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["source", "headers"],
+        properties: {
+          source: {
+            description: "A pattern that matches each incoming pathname (excluding querystring)",
+            type: "string",
+            maxLength: 4096
+          },
+          headers: {
+            description: "An array of key/value pairs representing each response header.",
+            type: "array",
+            maxItems: 1024,
+            items: {
+              type: "object",
+              additionalProperties: false,
+              required: ["key", "value"],
+              properties: {
+                key: {
+                  type: "string",
+                  maxLength: 4096
+                },
+                value: {
+                  type: "string",
+                  maxLength: 32768
+                }
+              }
+            }
+          },
+          has: hasSchema,
+          missing: hasSchema
+        }
+      }
+    };
+    var cleanUrlsSchema = {
+      description: "When set to `true`, all HTML files and Serverless Functions will have their extension removed. When visiting a path that ends with the extension, a 308 response will redirect the client to the extensionless path.",
+      type: "boolean"
+    };
+    var trailingSlashSchema = {
+      description: "When `false`, visiting a path that ends with a forward slash will respond with a `308` status code and redirect to the path without the trailing slash.",
+      type: "boolean"
+    };
+  }
+});
+
+// ../routing-utils/dist/types.js
+var require_types = __commonJS({
+  "../routing-utils/dist/types.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var types_exports = {};
+    module2.exports = __toCommonJS2(types_exports);
+  }
+});
+
+// ../routing-utils/dist/index.js
+var require_dist4 = __commonJS({
+  "../routing-utils/dist/index.js"(exports, module2) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __reExport = (target, mod, secondTarget) => (__copyProps2(target, mod, "default"), secondTarget && __copyProps2(secondTarget, mod, "default"));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var src_exports2 = {};
+    __export2(src_exports2, {
+      appendRoutesToPhase: () => import_append.appendRoutesToPhase,
+      compilePathToRegexpTemplate: () => import_superstatic2.compilePathToRegexpTemplate,
+      convertRewrites: () => import_superstatic2.convertRewrites,
+      getCleanUrls: () => import_superstatic2.getCleanUrls,
+      getOwnershipGuard: () => import_service_route_ownership.getOwnershipGuard,
+      getTransformedRoutes: () => getTransformedRoutes,
+      isHandler: () => isHandler,
+      isValidHandleValue: () => isValidHandleValue,
+      mergeRoutes: () => import_merge.mergeRoutes,
+      normalizeRoutePrefix: () => import_service_route_ownership.normalizeRoutePrefix,
+      normalizeRoutes: () => normalizeRoutes,
+      pathToRegexp: () => import_superstatic2.pathToRegexp,
+      scopeRouteSourceToOwnership: () => import_service_route_ownership.scopeRouteSourceToOwnership,
+      sourceToRegex: () => import_superstatic2.sourceToRegex
+    });
+    module2.exports = __toCommonJS2(src_exports2);
+    var import_url = require("url");
+    var import_superstatic = require_superstatic();
+    var import_append = require_append();
+    var import_merge = require_merge2();
+    var import_service_route_ownership = require_service_route_ownership();
+    __reExport(src_exports2, require_schemas(), module2.exports);
+    var import_superstatic2 = require_superstatic();
+    __reExport(src_exports2, require_types(), module2.exports);
+    var VALID_HANDLE_VALUES = [
+      "filesystem",
+      "hit",
+      "miss",
+      "rewrite",
+      "error",
+      "resource"
+    ];
+    var validHandleValues = new Set(VALID_HANDLE_VALUES);
+    function isHandler(route) {
+      return typeof route.handle !== "undefined";
+    }
+    function isValidHandleValue(handle) {
+      return validHandleValues.has(handle);
+    }
+    function convertRouteAliases(route, index) {
+      if (route.source !== void 0) {
+        if (route.src !== void 0) {
+          throw new Error(
+            `Route at index ${index} cannot define both \`src\` and \`source\`. Please use only one.`
+          );
+        }
+        route.src = route.source;
+        delete route.source;
+      }
+      if (route.destination !== void 0) {
+        if (route.dest !== void 0) {
+          throw new Error(
+            `Route at index ${index} cannot define both \`dest\` and \`destination\`. Please use only one.`
+          );
+        }
+        if (typeof route.destination === "string") {
+          route.dest = route.destination;
+          delete route.destination;
+        } else if (typeof route.destination.service === "string") {
+          route.destination = { ...route.destination, type: "service" };
+        }
+      }
+      if (route.statusCode !== void 0) {
+        if (route.status !== void 0) {
+          throw new Error(
+            `Route at index ${index} cannot define both \`status\` and \`statusCode\`. Please use only one.`
+          );
+        }
+        route.status = route.statusCode;
+        delete route.statusCode;
+      }
+    }
+    function normalizeRoutes(inputRoutes) {
+      if (!inputRoutes || inputRoutes.length === 0) {
+        return { routes: inputRoutes, error: null };
+      }
+      const routes = [];
+      const handling = [];
+      const errors = [];
+      inputRoutes.forEach((r, i) => {
+        const route = { ...r };
+        routes.push(route);
+        if (!isHandler(route)) {
+          try {
+            convertRouteAliases(route, i);
+          } catch (err) {
+            errors.push(err.message);
+          }
+        }
+        const keys = Object.keys(route);
+        if (isHandler(route)) {
+          const { handle } = route;
+          if (keys.length !== 1) {
+            const unknownProp = keys.find((prop) => prop !== "handle");
+            errors.push(
+              `Route at index ${i} has unknown property \`${unknownProp}\`.`
+            );
+          } else if (!isValidHandleValue(handle)) {
+            errors.push(
+              `Route at index ${i} has unknown handle value \`handle: ${handle}\`.`
+            );
+          } else if (handling.includes(handle)) {
+            errors.push(
+              `Route at index ${i} is a duplicate. Please use one \`handle: ${handle}\` at most.`
+            );
+          } else {
+            handling.push(handle);
+          }
+        } else if (route.src) {
+          if (!route.src.startsWith("^")) {
+            route.src = `^${route.src}`;
+          }
+          if (!route.src.endsWith("$")) {
+            route.src = `${route.src}$`;
+          }
+          route.src = route.src.replace(/\\\//g, "/");
+          const regError = checkRegexSyntax("Route", i, route.src);
+          if (regError) {
+            errors.push(regError);
+          }
+          if (route.destination && typeof route.destination === "object" && route.continue) {
+            errors.push(
+              `Route at index ${i} cannot define \`continue: true\` with a service \`destination\`. The service handoff is terminal.`
+            );
+          }
+          const handleValue = handling[handling.length - 1];
+          if (handleValue === "hit") {
+            if (route.dest) {
+              errors.push(
+                `Route at index ${i} cannot define \`dest\`/\`destination\` after \`handle: hit\`.`
+              );
+            }
+            if (route.status) {
+              errors.push(
+                `Route at index ${i} cannot define \`status\`/\`statusCode\` after \`handle: hit\`.`
+              );
+            }
+            if (!route.continue) {
+              errors.push(
+                `Route at index ${i} must define \`continue: true\` after \`handle: hit\`.`
+              );
+            }
+          } else if (handleValue === "miss") {
+            if (route.dest && !route.check) {
+              errors.push(
+                `Route at index ${i} must define \`check: true\` after \`handle: miss\`.`
+              );
+            } else if (!route.dest && !route.continue) {
+              errors.push(
+                `Route at index ${i} must define \`continue: true\` after \`handle: miss\`.`
+              );
+            }
+          }
+        } else {
+          errors.push(
+            `Route at index ${i} must define either \`src\` or \`source\` property.`
+          );
+        }
+      });
+      const error = errors.length > 0 ? createError(
+        "invalid_route",
+        errors,
+        "https://vercel.link/routes-json",
+        "Learn More"
+      ) : null;
+      return { routes, error };
+    }
+    function checkRegexSyntax(type, index, src) {
+      try {
+        new RegExp(src);
+      } catch (_err) {
+        const prop = type === "Route" ? "src`/`source" : "source";
+        return `${type} at index ${index} has invalid \`${prop}\` regular expression "${src}".`;
+      }
+      return null;
+    }
+    function checkPatternSyntax(type, index, {
+      source,
+      destination,
+      has,
+      transforms
+    }) {
+      let sourceSegments = /* @__PURE__ */ new Set();
+      const destinationSegments = /* @__PURE__ */ new Set();
+      try {
+        sourceSegments = new Set((0, import_superstatic.sourceToRegex)(source).segments);
+      } catch (_err) {
+        return {
+          message: `${type} at index ${index} has invalid \`source\` pattern "${source}".`,
+          link: "https://vercel.link/invalid-route-source-pattern"
+        };
+      }
+      const destinationString = typeof destination === "string" ? destination : typeof destination?.path === "string" ? destination.path : void 0;
+      if (destinationString !== void 0) {
+        try {
+          const { hostname, pathname, query } = (0, import_url.parse)(destinationString, true);
+          (0, import_superstatic.sourceToRegex)(hostname || "").segments.forEach(
+            (name) => destinationSegments.add(name)
+          );
+          (0, import_superstatic.sourceToRegex)(pathname || "").segments.forEach(
+            (name) => destinationSegments.add(name)
+          );
+          for (const strOrArray of Object.values(query)) {
+            const value = Array.isArray(strOrArray) ? strOrArray[0] : strOrArray;
+            (0, import_superstatic.sourceToRegex)(value || "").segments.forEach(
+              (name) => destinationSegments.add(name)
+            );
+          }
+        } catch (_err) {
+        }
+        const hasSegments = (0, import_superstatic.collectHasSegments)(has);
+        for (const segment of destinationSegments) {
+          if (!sourceSegments.has(segment) && !hasSegments.includes(segment)) {
+            return {
+              message: `${type} at index ${index} has segment ":${segment}" in \`destination\` property but not in \`source\` or \`has\` property.`,
+              link: "https://vercel.link/invalid-route-destination-segment"
+            };
+          }
+        }
+      }
+      for (const transform of transforms || []) {
+        if (transform.type !== "request.path") {
+          continue;
+        }
+        try {
+          (0, import_superstatic.compilePathToRegexpTemplate)(source, transform.args, has, transform.env);
+        } catch (error) {
+          return {
+            message: `${type} at index ${index} has an invalid \`request.path\` transform: ${error instanceof Error ? error.message : String(error)}`,
+            link: "https://vercel.link/invalid-route-destination-segment"
+          };
+        }
+      }
+      return null;
+    }
+    function checkRedirect(r, index) {
+      if (typeof r.permanent !== "undefined" && typeof r.statusCode !== "undefined") {
+        return `Redirect at index ${index} cannot define both \`permanent\` and \`statusCode\` properties.`;
+      }
+      return null;
+    }
+    function createError(code, allErrors, link, action) {
+      const errors = Array.isArray(allErrors) ? allErrors : [allErrors];
+      const message = errors[0];
+      const error = {
+        name: "RouteApiError",
+        code,
+        message,
+        link,
+        action,
+        errors
+      };
+      return error;
+    }
+    function notEmpty(value) {
+      return value !== null && value !== void 0;
+    }
+    function getTransformedRoutes(vercelConfig) {
+      const { cleanUrls, rewrites, redirects, headers, trailingSlash } = vercelConfig;
+      const { routes: userRoutes = null } = vercelConfig;
+      let routes = null;
+      if (typeof cleanUrls !== "undefined") {
+        const normalized = normalizeRoutes(
+          (0, import_superstatic.convertCleanUrls)(cleanUrls, trailingSlash)
+        );
+        if (normalized.error) {
+          normalized.error.code = "invalid_clean_urls";
+          return { routes, error: normalized.error };
+        }
+        routes = routes || [];
+        routes.push(...normalized.routes || []);
+      }
+      if (typeof trailingSlash !== "undefined") {
+        const normalized = normalizeRoutes((0, import_superstatic.convertTrailingSlash)(trailingSlash));
+        if (normalized.error) {
+          normalized.error.code = "invalid_trailing_slash";
+          return { routes, error: normalized.error };
+        }
+        routes = routes || [];
+        routes.push(...normalized.routes || []);
+      }
+      if (userRoutes) {
+        const normalized = normalizeRoutes(userRoutes);
+        if (normalized.error) {
+          return { routes, error: normalized.error };
+        }
+        routes = routes || [];
+        routes.push(...normalized.routes || []);
+      }
+      if (typeof redirects !== "undefined") {
+        const code = "invalid_redirect";
+        const regexErrorMessage = redirects.map((r, i) => checkRegexSyntax("Redirect", i, r.source)).find(notEmpty);
+        if (regexErrorMessage) {
+          return {
+            routes,
+            error: createError(
+              "invalid_redirect",
+              regexErrorMessage,
+              "https://vercel.link/invalid-route-source-pattern",
+              "Learn More"
+            )
+          };
+        }
+        const patternError = redirects.map((r, i) => checkPatternSyntax("Redirect", i, r)).find(notEmpty);
+        if (patternError) {
+          return {
+            routes,
+            error: createError(
+              code,
+              patternError.message,
+              patternError.link,
+              "Learn More"
+            )
+          };
+        }
+        const redirectErrorMessage = redirects.map(checkRedirect).find(notEmpty);
+        if (redirectErrorMessage) {
+          return {
+            routes,
+            error: createError(
+              code,
+              redirectErrorMessage,
+              "https://vercel.link/redirects-json",
+              "Learn More"
+            )
+          };
+        }
+        const normalized = normalizeRoutes((0, import_superstatic.convertRedirects)(redirects));
+        if (normalized.error) {
+          normalized.error.code = code;
+          return { routes, error: normalized.error };
+        }
+        routes = routes || [];
+        routes.push(...normalized.routes || []);
+      }
+      if (typeof headers !== "undefined") {
+        const code = "invalid_header";
+        const regexErrorMessage = headers.map((r, i) => checkRegexSyntax("Header", i, r.source)).find(notEmpty);
+        if (regexErrorMessage) {
+          return {
+            routes,
+            error: createError(
+              code,
+              regexErrorMessage,
+              "https://vercel.link/invalid-route-source-pattern",
+              "Learn More"
+            )
+          };
+        }
+        const patternError = headers.map((r, i) => checkPatternSyntax("Header", i, r)).find(notEmpty);
+        if (patternError) {
+          return {
+            routes,
+            error: createError(
+              code,
+              patternError.message,
+              patternError.link,
+              "Learn More"
+            )
+          };
+        }
+        const normalized = normalizeRoutes((0, import_superstatic.convertHeaders)(headers));
+        if (normalized.error) {
+          normalized.error.code = code;
+          return { routes, error: normalized.error };
+        }
+        routes = routes || [];
+        routes.push(...normalized.routes || []);
+      }
+      if (typeof rewrites !== "undefined") {
+        const code = "invalid_rewrite";
+        const regexErrorMessage = rewrites.map((r, i) => checkRegexSyntax("Rewrite", i, r.source)).find(notEmpty);
+        if (regexErrorMessage) {
+          return {
+            routes,
+            error: createError(
+              code,
+              regexErrorMessage,
+              "https://vercel.link/invalid-route-source-pattern",
+              "Learn More"
+            )
+          };
+        }
+        const patternError = rewrites.map((r, i) => checkPatternSyntax("Rewrite", i, r)).find(notEmpty);
+        if (patternError) {
+          return {
+            routes,
+            error: createError(
+              code,
+              patternError.message,
+              patternError.link,
+              "Learn More"
+            )
+          };
+        }
+        const normalized = normalizeRoutes((0, import_superstatic.convertRewrites)(rewrites));
+        if (normalized.error) {
+          normalized.error.code = code;
+          return { routes, error: normalized.error };
+        }
+        routes = routes || [];
+        routes.push({ handle: "filesystem" });
+        routes.push(...normalized.routes || []);
+      }
+      return { routes, error: null };
+    }
+  }
+});
+
 // ../../node_modules/.pnpm/bytes@3.1.2/node_modules/bytes/index.js
 var require_bytes = __commonJS({
   "../../node_modules/.pnpm/bytes@3.1.2/node_modules/bytes/index.js"(exports, module2) {
@@ -31618,6 +34386,7 @@ __export(src_exports, {
   getNodeBinPath: () => getNodeBinPath,
   getNodeBinPaths: () => getNodeBinPaths,
   getNodeVersion: () => getNodeVersion,
+  getOrCreateBunBinary: () => getOrCreateBunBinary,
   getPackageJson: () => getPackageJson,
   getPathForPackageManager: () => getPathForPackageManager,
   getPlatformEnv: () => getPlatformEnv,
@@ -31625,6 +34394,7 @@ __export(src_exports, {
   getPrerenderChain: () => getPrerenderChain,
   getPrettyError: () => getPrettyError,
   getProvidedRuntime: () => getProvidedRuntime,
+  getRegExpFromMatchers: () => getRegExpFromMatchers,
   getReportedServiceType: () => getReportedServiceType,
   getScriptName: () => getScriptName,
   getServiceQueueTopicConfigs: () => getServiceQueueTopicConfigs,
@@ -31670,6 +34440,7 @@ __export(src_exports, {
   readConfigFile: () => readConfigFile,
   rename: () => rename,
   resetCustomInstallCommandSet: () => resetCustomInstallCommandSet,
+  resolveMiddlewareMatcher: () => resolveMiddlewareMatcher,
   runBundleInstall: () => runBundleInstall,
   runCustomInstallCommand: () => runCustomInstallCommand,
   runNpmInstall: () => runNpmInstall,
@@ -33026,6 +35797,12 @@ var NODE_VERSIONS = [
   })
 ];
 var BUN_VERSIONS = [
+  new BunVersion({
+    major: 1,
+    minor: 4,
+    range: "1.4.x",
+    runtime: "bun1.4.x"
+  }),
   new BunVersion({
     major: 1,
     range: "1.x",
@@ -33115,11 +35892,15 @@ async function getSupportedNodeVersion(engineRange, isAuto = false, availableVer
 function getSupportedBunVersion(engineRange) {
   if ((0, import_semver.validRange)(engineRange)) {
     const selected = BUN_VERSIONS.find((version) => {
-      return (0, import_semver.intersects)(version.range, engineRange);
+      if (!(0, import_semver.intersects)(version.range, engineRange)) {
+        return false;
+      }
+      return version.minor === void 0 ? true : !(0, import_semver.intersects)(`<${version.major}.${version.minor}.0`, engineRange);
     });
     if (selected) {
       return new BunVersion({
         major: selected.major,
+        minor: selected.minor,
         range: selected.range,
         runtime: selected.runtime
       });
@@ -34544,6 +37325,7 @@ function getEnvForPackageManager({
   cliType,
   lockfileVersion,
   packageJsonPackageManager,
+  nodeVersion,
   env,
   packageJsonEngines,
   turboSupportsCorepackHome,
@@ -34563,6 +37345,7 @@ function getEnvForPackageManager({
     lockfileVersion,
     corepackPackageManager: packageJsonPackageManager,
     corepackEnabled,
+    nodeVersion,
     packageJsonEngines,
     projectCreatedAt
   });
@@ -34578,14 +37361,23 @@ function getEnvForPackageManager({
   const newEnv = {
     ...env
   };
+  const bunRuntimePath = nodeVersion && isBunVersion(nodeVersion) ? `/bun${nodeVersion.major}${nodeVersion.minor === void 0 ? "" : `.${nodeVersion.minor}`}` : void 0;
   const alreadyInPath = (newPath2) => {
     const oldPath = env.PATH ?? "";
     return oldPath.split(import_path6.default.delimiter).includes(newPath2);
   };
-  if (newPath && !alreadyInPath(newPath)) {
+  const hasSelectedBunPath = cliType === "bun" && nodeVersion === void 0 && (env.PATH ?? "").split(import_path6.default.delimiter).some((segment) => /^\/bun\d+(?:\.\d+)?$/.test(segment));
+  const pathsToPrepend = Array.from(
+    new Set(
+      [newPath, bunRuntimePath].filter((value) => !!value)
+    )
+  ).filter(
+    (value) => !alreadyInPath(value) && !(hasSelectedBunPath && value === newPath)
+  );
+  if (pathsToPrepend.length > 0) {
     const oldPath = env.PATH + "";
-    newEnv.PATH = `${newPath}${import_path6.default.delimiter}${oldPath}`;
-    if (detectedLockfile && detectedPackageManager) {
+    newEnv.PATH = `${pathsToPrepend.join(import_path6.default.delimiter)}${oldPath ? import_path6.default.delimiter : ""}${oldPath}`;
+    if (newPath && pathsToPrepend.includes(newPath) && detectedLockfile && detectedPackageManager) {
       const detectedV9PnpmLockfile = detectedLockfile === "pnpm-lock.yaml" && lockfileVersion === 9;
       const pnpm10UsingPackageJsonPackageManager = detectedPackageManager === "pnpm@10.x" && packageJsonPackageManager;
       if (pnpm10UsingPackageJsonPackageManager) {
@@ -34681,6 +37473,7 @@ function getPathOverrideForPackageManager({
   lockfileVersion,
   corepackPackageManager,
   corepackEnabled = true,
+  nodeVersion,
   packageJsonEngines,
   projectCreatedAt
 }) {
@@ -34708,6 +37501,14 @@ function getPathOverrideForPackageManager({
       );
     }
   }
+  if (cliType === "bun" && detectedPackageManger && nodeVersion && isBunVersion(nodeVersion)) {
+    const minor = nodeVersion.minor;
+    return {
+      ...detectedPackageManger,
+      path: `/bun${nodeVersion.major}${minor === void 0 ? "" : `.${minor}`}`,
+      detectedPackageManager: `bun@${nodeVersion.range}`
+    };
+  }
   return detectedPackageManger ?? NO_OVERRIDE;
 }
 function checkEnginesPnpmAgainstDetected(enginesPnpm, detectedPackageManger) {
@@ -35018,8 +37819,67 @@ var installDependencies = (0, import_util6.deprecate)(
   "installDependencies() is deprecated. Please use runNpmInstall() instead."
 );
 
+// src/fs/bun-helpers.ts
+var import_os2 = require("os");
+var import_path7 = require("path");
+var import_child_process = require("child_process");
+function spawnAsync2(command, args, options) {
+  return new Promise((resolve, reject) => {
+    const child = (0, import_child_process.spawn)(command, args, options);
+    child.once("error", reject);
+    child.once("close", resolve);
+  });
+}
+async function getOrCreateBunBinary() {
+  const bunCommand = process.platform === "win32" ? "bun.exe" : "bun";
+  const installPath = (0, import_path7.join)((0, import_os2.homedir)(), ".bun", "bin", bunCommand);
+  try {
+    if (await spawnAsync2(bunCommand, ["--version"], { stdio: "ignore" }) === 0) {
+      debug("Bun already installed and available in PATH");
+      return bunCommand;
+    }
+  } catch {
+    debug("Bun not found in PATH");
+  }
+  try {
+    if (await spawnAsync2(installPath, ["--version"], { stdio: "ignore" }) === 0) {
+      debug("Bun already installed in default location");
+      return installPath;
+    }
+  } catch {
+    debug("Bun not found in default location");
+  }
+  console.log("Installing Bun...");
+  try {
+    const exitCode = process.platform === "win32" ? await spawnAsync2(
+      "powershell",
+      ["-c", "irm bun.sh/install.ps1 | iex"],
+      { stdio: "inherit" }
+    ) : await spawnAsync2(
+      "bash",
+      ["-c", "curl -fsSL https://bun.sh/install | bash"],
+      { stdio: "inherit" }
+    );
+    if (exitCode !== 0) {
+      throw new Error(`Installation script exited with code ${exitCode}`);
+    }
+  } catch (error) {
+    throw new Error(`Failed to install Bun: ${error}`);
+  }
+  try {
+    if (await spawnAsync2(installPath, ["--version"], { stdio: "ignore" }) === 0) {
+      debug("Bun was installed successfully");
+      return installPath;
+    }
+  } catch {
+  }
+  throw new Error(
+    "Bun installation failed. Please install manually and try again."
+  );
+}
+
 // src/get-ignore-filter.ts
-var import_path7 = __toESM(require("path"));
+var import_path8 = __toESM(require("path"));
 var import_fs_extra8 = __toESM(require_lib());
 var import_ignore = __toESM(require_ignore());
 function isCodedError(error) {
@@ -35039,12 +37899,12 @@ async function get_ignore_filter_default(downloadPath, rootDirectory) {
       throw error;
     }
   };
-  const vercelIgnorePath = import_path7.default.join(
+  const vercelIgnorePath = import_path8.default.join(
     downloadPath,
     rootDirectory || "",
     ".vercelignore"
   );
-  const nowIgnorePath = import_path7.default.join(
+  const nowIgnorePath = import_path8.default.join(
     downloadPath,
     rootDirectory || "",
     ".nowignore"
@@ -35209,22 +38069,22 @@ function getExperimentalServiceUrlEnvVars(options) {
 }
 
 // src/hard-link-dir.ts
-var import_path8 = __toESM(require("path"));
+var import_path9 = __toESM(require("path"));
 var import_fs2 = require("fs");
 async function hardLinkDir(src, destDirs) {
   if (destDirs.length === 0)
     return;
-  destDirs = destDirs.filter((destDir) => import_path8.default.relative(destDir, src) !== "");
+  destDirs = destDirs.filter((destDir) => import_path9.default.relative(destDir, src) !== "");
   const files = await import_fs2.promises.readdir(src);
   await Promise.all(
     files.map(async (file) => {
       if (file === "node_modules")
         return;
-      const srcFile = import_path8.default.join(src, file);
+      const srcFile = import_path9.default.join(src, file);
       if ((await import_fs2.promises.lstat(srcFile)).isDirectory()) {
         const destSubdirs = await Promise.all(
           destDirs.map(async (destDir) => {
-            const destSubdir = import_path8.default.join(destDir, file);
+            const destSubdir = import_path9.default.join(destDir, file);
             try {
               await import_fs2.promises.mkdir(destSubdir, { recursive: true });
             } catch (err) {
@@ -35239,7 +38099,7 @@ async function hardLinkDir(src, destDirs) {
       }
       await Promise.all(
         destDirs.map(async (destDir) => {
-          const destFile = import_path8.default.join(destDir, file);
+          const destFile = import_path9.default.join(destDir, file);
           try {
             await linkOrCopyFile(srcFile, destFile);
           } catch (err) {
@@ -35258,7 +38118,7 @@ async function linkOrCopyFile(srcFile, destFile) {
     await linkOrCopy(srcFile, destFile);
   } catch (err) {
     if (err.code === "ENOENT") {
-      await import_fs2.promises.mkdir(import_path8.default.dirname(destFile), { recursive: true });
+      await import_fs2.promises.mkdir(import_path9.default.dirname(destFile), { recursive: true });
       await linkOrCopy(srcFile, destFile);
       return;
     }
@@ -35278,10 +38138,10 @@ async function linkOrCopy(srcFile, destFile) {
 }
 
 // src/validate-npmrc.ts
-var import_path9 = require("path");
+var import_path10 = require("path");
 var import_promises = require("fs/promises");
 async function validateNpmrc(cwd) {
-  const npmrc = await (0, import_promises.readFile)((0, import_path9.join)(cwd, ".npmrc"), "utf-8").catch((err) => {
+  const npmrc = await (0, import_promises.readFile)((0, import_path10.join)(cwd, ".npmrc"), "utf-8").catch((err) => {
     if (err.code !== "ENOENT")
       throw err;
   });
@@ -35334,7 +38194,7 @@ async function getProvidedRuntime() {
 }
 
 // src/should-serve.ts
-var import_path10 = require("path");
+var import_path11 = require("path");
 var shouldServe = ({
   entrypoint,
   files,
@@ -35345,7 +38205,7 @@ var shouldServe = ({
   if (entrypoint === requestPath && hasProp2(files, entrypoint)) {
     return true;
   }
-  const { dir, name } = (0, import_path10.parse)(entrypoint);
+  const { dir, name } = (0, import_path11.parse)(entrypoint);
   if (name === "index" && dir === requestPath && hasProp2(files, entrypoint)) {
     return true;
   }
@@ -35608,21 +38468,21 @@ var packageManifestSchema = {
 
 // src/package-manifest.ts
 var import_fs3 = __toESM(require("fs"));
-var import_path11 = require("path");
+var import_path12 = require("path");
 var MANIFEST_VERSION = "20260304";
 var MANIFEST_FILENAME = "package-manifest.json";
 function manifestPath(runtime) {
-  return (0, import_path11.join)(".vercel", runtime, MANIFEST_FILENAME);
+  return (0, import_path12.join)(".vercel", runtime, MANIFEST_FILENAME);
 }
 async function writeProjectManifest(manifest, workPath, runtime) {
-  const outPath = (0, import_path11.join)(workPath, manifestPath(runtime));
-  await import_fs3.default.promises.mkdir((0, import_path11.dirname)(outPath), { recursive: true });
+  const outPath = (0, import_path12.join)(workPath, manifestPath(runtime));
+  await import_fs3.default.promises.mkdir((0, import_path12.dirname)(outPath), { recursive: true });
   await import_fs3.default.promises.writeFile(outPath, JSON.stringify(manifest, null, 2));
 }
 function createDiagnostics(runtime) {
   return async ({ workPath }) => {
     try {
-      const filePath = (0, import_path11.join)(workPath, manifestPath(runtime));
+      const filePath = (0, import_path12.join)(workPath, manifestPath(runtime));
       const data = await import_fs3.default.promises.readFile(filePath, "utf-8");
       return {
         [MANIFEST_FILENAME]: new FileBlob({ data })
@@ -35635,7 +38495,7 @@ function createDiagnostics(runtime) {
 
 // src/node-diagnostics.ts
 var import_fs4 = __toESM(require("fs"));
-var import_path12 = __toESM(require("path"));
+var import_path13 = __toESM(require("path"));
 var import_js_yaml3 = __toESM(require_js_yaml2());
 var import_parsers = __toESM(require_lib4());
 function classifySource(resolvedUrl) {
@@ -35947,12 +38807,12 @@ async function readPackageJson(startDir) {
   for (; ; ) {
     try {
       const content = await import_fs4.default.promises.readFile(
-        import_path12.default.join(current, "package.json"),
+        import_path13.default.join(current, "package.json"),
         "utf-8"
       );
       return JSON.parse(content);
     } catch {
-      const parent = import_path12.default.dirname(current);
+      const parent = import_path13.default.dirname(current);
       if (parent === current)
         return null;
       current = parent;
@@ -36040,7 +38900,7 @@ async function generateProjectManifest({
       for (const filename of [".node-version", ".nvmrc"]) {
         try {
           const val = await import_fs4.default.promises.readFile(
-            import_path12.default.join(workPath, filename),
+            import_path13.default.join(workPath, filename),
             "utf-8"
           );
           const trimmed = val.trim();
@@ -36519,6 +39379,42 @@ ${entrypointsForMessage}`
   };
 }
 
+// src/middleware-matcher.ts
+var import_routing_utils = __toESM(require_dist4());
+function getRegExpFromMatchers(matcherOrMatchers) {
+  if (!matcherOrMatchers) {
+    return "^/.*$";
+  }
+  const matchers = Array.isArray(matcherOrMatchers) ? matcherOrMatchers : [matcherOrMatchers];
+  const regExps = matchers.flatMap(getRegExpFromMatcher).join("|");
+  return regExps;
+}
+function resolveMiddlewareMatcher(configuredMatcher, sourceMatcher, entrypoint) {
+  if (configuredMatcher !== void 0 && sourceMatcher !== void 0) {
+    throw new Error(
+      `${entrypoint}: \`proxy.matcher\` in vercel.json conflicts with \`config.matcher\` exported from the proxy entrypoint. Configure the matcher in only one location.`
+    );
+  }
+  return configuredMatcher ?? sourceMatcher;
+}
+function getRegExpFromMatcher(matcher, _index, allMatchers) {
+  if (typeof matcher !== "string") {
+    throw new Error(
+      "Middleware's `config.matcher` must be a path matcher (string) or an array of path matchers (string[])"
+    );
+  }
+  if (!matcher.startsWith("/")) {
+    throw new Error(
+      `Middleware's \`config.matcher\` values must start with "/". Received: ${matcher}`
+    );
+  }
+  const regExps = [(0, import_routing_utils.pathToRegexp)("316", matcher).source];
+  if (matcher === "/" && !allMatchers.includes("/index")) {
+    regExps.push((0, import_routing_utils.pathToRegexp)("491", "/index").source);
+  }
+  return regExps;
+}
+
 // src/framework-helpers.ts
 var BACKEND_FRAMEWORKS = [
   "express",
@@ -37030,6 +39926,7 @@ var SUPPORTED_AL2023_RUNTIMES = [
   "python3.13",
   "python3.14",
   "ruby3.3",
+  "bun1.4.x",
   "bun1.x",
   "executable"
 ];
@@ -37370,11 +40267,11 @@ function validateFrameworkVersion(framework) {
 }
 
 // src/deserialize/hydrate-files-map.ts
-var import_path13 = require("path");
+var import_path14 = require("path");
 async function hydrateFilesMap(files, filesMap, repoRootPath, fileFsRefsCache) {
   for (const [funcPath, projectPath] of Object.entries(filesMap)) {
     files[funcPath] = await fileFsRefCached(
-      (0, import_path13.join)(repoRootPath, projectPath),
+      (0, import_path14.join)(repoRootPath, projectPath),
       fileFsRefsCache
     );
   }
@@ -37389,7 +40286,7 @@ async function fileFsRefCached(fsPath, cache) {
 }
 
 // src/deserialize/create-functions-iterator.ts
-var import_path14 = require("path");
+var import_path15 = require("path");
 var import_fs_extra9 = __toESM(require_lib());
 var SUFFIX = ".func";
 async function* createFunctionsIterator(dir, root = dir) {
@@ -37403,11 +40300,11 @@ async function* createFunctionsIterator(dir, root = dir) {
     paths = [];
   }
   for (const path8 of paths) {
-    const abs = (0, import_path14.join)(dir, path8);
+    const abs = (0, import_path15.join)(dir, path8);
     const s = await (0, import_fs_extra9.stat)(abs);
     if (s.isDirectory()) {
       if (path8.endsWith(SUFFIX)) {
-        yield (0, import_path14.relative)(root, abs.substring(0, abs.length - SUFFIX.length));
+        yield (0, import_path15.relative)(root, abs.substring(0, abs.length - SUFFIX.length));
       } else {
         yield* createFunctionsIterator(abs, root);
       }
@@ -37429,7 +40326,7 @@ async function maybeReadJSON(path8) {
 
 // src/deserialize/deserialize-build-output.ts
 var fs11 = __toESM(require_lib());
-var import_path15 = require("path");
+var import_path16 = require("path");
 
 // src/deserialize/deserialize-edge-function.ts
 async function deserializeEdgeFunction(files, config, repoRootPath, fileFsRefsCache) {
@@ -37492,14 +40389,14 @@ function applyOutputOverrides(output, overrides, warn) {
 async function deserializePrerenderFallback(prerenderConfigPath, fallbackConfig) {
   if (typeof fallbackConfig === "string") {
     return file_fs_ref_default.fromFsPath({
-      fsPath: (0, import_path15.join)((0, import_path15.dirname)(prerenderConfigPath), fallbackConfig)
+      fsPath: (0, import_path16.join)((0, import_path16.dirname)(prerenderConfigPath), fallbackConfig)
     });
   }
   if (fallbackConfig) {
     return file_fs_ref_default.fromFsPath({
       mode: fallbackConfig.mode,
       contentType: fallbackConfig.contentType,
-      fsPath: (0, import_path15.join)((0, import_path15.dirname)(prerenderConfigPath), fallbackConfig.fsPath)
+      fsPath: (0, import_path16.join)((0, import_path16.dirname)(prerenderConfigPath), fallbackConfig.fsPath)
     });
   }
   return null;
@@ -37585,7 +40482,7 @@ async function deserializeBuildOutput(options) {
     getMeta
   } = options;
   let hasServerActions = false;
-  const configPath = (0, import_path15.join)(outputDir, "config.json");
+  const configPath = (0, import_path16.join)(outputDir, "config.json");
   const config = await maybeReadJSON(configPath);
   if (!config) {
     throw new Error(`Config file was not found at "${configPath}"`);
@@ -37596,8 +40493,8 @@ async function deserializeBuildOutput(options) {
     );
   }
   validateDeploymentId(config.deploymentId);
-  const flags = await maybeReadJSON((0, import_path15.join)(outputDir, "flags.json"));
-  const staticDir = (0, import_path15.join)(outputDir, "static");
+  const flags = await maybeReadJSON((0, import_path16.join)(outputDir, "flags.json"));
+  const staticDir = (0, import_path16.join)(outputDir, "static");
   const output = await glob("**", {
     cwd: staticDir,
     follow: true
@@ -37605,19 +40502,19 @@ async function deserializeBuildOutput(options) {
   applyOutputOverrides(output, config.overrides, warn);
   const fileFsRefsCache = /* @__PURE__ */ new Map();
   const prerenders = /* @__PURE__ */ new Map();
-  const functionsDir = (0, import_path15.join)(outputDir, "functions");
+  const functionsDir = (0, import_path16.join)(outputDir, "functions");
   const functionSymlinks = /* @__PURE__ */ new Map();
   for await (const path8 of createFunctionsIterator(functionsDir)) {
     let lambda = void 0;
-    const fnDir = (0, import_path15.join)(functionsDir, `${path8}.func`);
+    const fnDir = (0, import_path16.join)(functionsDir, `${path8}.func`);
     try {
       const link = await fs11.readlink(fnDir);
-      const target = (0, import_path15.join)((0, import_path15.dirname)(path8), link).slice(0, -5);
+      const target = (0, import_path16.join)((0, import_path16.dirname)(path8), link).slice(0, -5);
       functionSymlinks.set(path8, target);
     } catch (err) {
       if (err.code !== "EINVAL")
         throw err;
-      const funcConfigPath = (0, import_path15.join)(fnDir, ".vc-config.json");
+      const funcConfigPath = (0, import_path16.join)(fnDir, ".vc-config.json");
       const funcConfig = await maybeReadJSON(
         funcConfigPath
       );
@@ -37651,7 +40548,7 @@ async function deserializeBuildOutput(options) {
         );
       }
     }
-    const prerenderConfigPath = (0, import_path15.join)(
+    const prerenderConfigPath = (0, import_path16.join)(
       functionsDir,
       `${path8}.prerender-config.json`
     );
@@ -37751,13 +40648,13 @@ function validatePrerender(prerender) {
 }
 
 // src/collect-build-result/get-content-type.ts
-var import_path16 = require("path");
+var import_path17 = require("path");
 var import_mime_types = __toESM(require_mime_types());
 function getContentType(path8) {
   if (path8.endsWith(".html")) {
     return "text/html; charset=utf-8";
   }
-  return import_mime_types.default.contentType((0, import_path16.extname)(path8)) || "application/octet-stream";
+  return import_mime_types.default.contentType((0, import_path17.extname)(path8)) || "application/octet-stream";
 }
 
 // src/collect-build-result/file-to-build-output-file.ts
@@ -37911,6 +40808,7 @@ function getExtendedPayload({
   getNodeBinPath,
   getNodeBinPaths,
   getNodeVersion,
+  getOrCreateBunBinary,
   getPackageJson,
   getPathForPackageManager,
   getPlatformEnv,
@@ -37918,6 +40816,7 @@ function getExtendedPayload({
   getPrerenderChain,
   getPrettyError,
   getProvidedRuntime,
+  getRegExpFromMatchers,
   getReportedServiceType,
   getScriptName,
   getServiceQueueTopicConfigs,
@@ -37963,6 +40862,7 @@ function getExtendedPayload({
   readConfigFile,
   rename,
   resetCustomInstallCommandSet,
+  resolveMiddlewareMatcher,
   runBundleInstall,
   runCustomInstallCommand,
   runNpmInstall,