@vercel/static-build 2.8.37 → 2.8.38

package/dist/index.js

@@ -9312,6 +9312,7 @@ var require_frameworks = __commonJS({
         tagline: "SvelteKit is a framework for building web applications of all sizes.",
         description: "A SvelteKit legacy app optimized Edge-first.",
         website: "https://kit.svelte.dev",
+        supersedes: ["vite"],
         sort: 99,
         envPrefix: "VITE_",
         detectors: {
@@ -9349,6 +9350,7 @@ var require_frameworks = __commonJS({
         tagline: "SvelteKit is a framework for building web applications of all sizes.",
         description: "A SvelteKit app optimized Edge-first.",
         website: "https://kit.svelte.dev",
+        supersedes: ["vite"],
         detectors: {
           every: [
             {
@@ -19729,185 +19731,2729 @@ var require_is_official_runtime = __commonJS({
   }
 });
 
-// ../fs-detectors/dist/services/types.js
-var require_types2 = __commonJS({
-  "../fs-detectors/dist/services/types.js"(exports2, module2) {
+// ../../node_modules/.pnpm/path-to-regexp@6.1.0/node_modules/path-to-regexp/dist/index.js
+var require_dist4 = __commonJS({
+  "../../node_modules/.pnpm/path-to-regexp@6.1.0/node_modules/path-to-regexp/dist/index.js"(exports2) {
     "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 });
+    Object.defineProperty(exports2, "__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++] });
       }
-      return to;
-    };
-    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
-    var types_exports = {};
-    __export2(types_exports, {
-      ENTRYPOINT_EXTENSIONS: () => ENTRYPOINT_EXTENSIONS,
-      ROUTE_OWNING_BUILDERS: () => ROUTE_OWNING_BUILDERS,
-      RUNTIME_BUILDERS: () => RUNTIME_BUILDERS,
-      STATIC_BUILDERS: () => STATIC_BUILDERS
-    });
-    module2.exports = __toCommonJS2(types_exports);
-    var RUNTIME_BUILDERS = {
-      node: "@vercel/node",
-      python: "@vercel/python",
-      go: "@vercel/go",
-      rust: "@vercel/rust",
-      ruby: "@vercel/ruby"
-    };
-    var ENTRYPOINT_EXTENSIONS = {
-      ".ts": "node",
-      ".mts": "node",
-      ".js": "node",
-      ".mjs": "node",
-      ".cjs": "node",
-      ".py": "python",
-      ".go": "go",
-      ".rs": "rust",
-      ".rb": "ruby",
-      ".ru": "ruby"
-    };
-    var STATIC_BUILDERS = /* @__PURE__ */ new Set([
-      "@vercel/static-build",
-      "@vercel/static"
-    ]);
-    var ROUTE_OWNING_BUILDERS = /* @__PURE__ */ new Set([
-      "@vercel/next",
-      "@vercel/backends"
-    ]);
-  }
-});
-
-// ../fs-detectors/dist/services/utils.js
-var require_utils4 = __commonJS({
-  "../fs-detectors/dist/services/utils.js"(exports2, 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 });
+      tokens.push({ type: "END", index: i, value: "" });
+      return tokens;
+    }
+    function parse(str, options) {
+      if (options === void 0) {
+        options = {};
       }
-      return to;
-    };
-    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
-    var utils_exports = {};
-    __export2(utils_exports, {
-      getBuilderForRuntime: () => getBuilderForRuntime,
-      inferServiceRuntime: () => inferServiceRuntime,
-      isRouteOwningBuilder: () => isRouteOwningBuilder2,
-      isStaticBuild: () => isStaticBuild2,
-      readVercelConfig: () => readVercelConfig
-    });
-    module2.exports = __toCommonJS2(utils_exports);
-    var import_framework_helpers = require("@vercel/build-utils/dist/framework-helpers");
-    var import_types = require_types2();
-    function getBuilderForRuntime(runtime) {
-      const builder = import_types.RUNTIME_BUILDERS[runtime];
-      if (!builder) {
-        throw new Error(`Unknown runtime: ${runtime}`);
+      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 path6 = "";
+      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) {
+            path6 += prefix;
+            prefix = "";
+          }
+          if (path6) {
+            result.push(path6);
+            path6 = "";
+          }
+          result.push({
+            name: name || key++,
+            prefix,
+            suffix: "",
+            pattern: pattern || defaultPattern,
+            modifier: tryConsume("MODIFIER") || ""
+          });
+          continue;
+        }
+        var value = char || tryConsume("ESCAPED_CHAR");
+        if (value) {
+          path6 += value;
+          continue;
+        }
+        if (path6) {
+          result.push(path6);
+          path6 = "";
+        }
+        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 builder;
-    }
-    function isStaticBuild2(service) {
-      return import_types.STATIC_BUILDERS.has(service.builder.use);
+      return result;
     }
-    function isRouteOwningBuilder2(service) {
-      return import_types.ROUTE_OWNING_BUILDERS.has(service.builder.use);
+    exports2.parse = parse;
+    function compile(str, options) {
+      return tokensToFunction(parse(str, options), options);
     }
-    function inferServiceRuntime(config) {
-      if (config.runtime && config.runtime in import_types.RUNTIME_BUILDERS) {
-        return config.runtime;
-      }
-      if ((0, import_framework_helpers.isPythonFramework)(config.framework)) {
-        return "python";
-      }
-      if ((0, import_framework_helpers.isBackendFramework)(config.framework)) {
-        return "node";
+    exports2.compile = compile;
+    function tokensToFunction(tokens, options) {
+      if (options === void 0) {
+        options = {};
       }
-      if (config.builder) {
-        for (const [runtime, builderName] of Object.entries(import_types.RUNTIME_BUILDERS)) {
-          if (config.builder === builderName) {
-            return runtime;
+      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 path6 = "";
+        for (var i = 0; i < tokens.length; i++) {
+          var token = tokens[i];
+          if (typeof token === "string") {
+            path6 += 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 + '"');
+              }
+              path6 += 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 + '"');
+            }
+            path6 += 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 path6;
+      };
+    }
+    exports2.tokensToFunction = tokensToFunction;
+    function match(str, options) {
+      var keys = [];
+      var re = pathToRegexp(str, keys, options);
+      return regexpToFunction(re, keys, options);
+    }
+    exports2.match = match;
+    function regexpToFunction(re, keys, options) {
+      if (options === void 0) {
+        options = {};
       }
-      if (config.entrypoint) {
-        for (const [ext, runtime] of Object.entries(import_types.ENTRYPOINT_EXTENSIONS)) {
-          if (config.entrypoint.endsWith(ext)) {
-            return runtime;
+      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 path6 = 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: path6, index, params };
+      };
+    }
+    exports2.regexpToFunction = regexpToFunction;
+    function escapeString(str) {
+      return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+    }
+    function flags(options) {
+      return options && options.sensitive ? "" : "i";
+    }
+    function regexpToRegexp(path6, keys) {
+      if (!keys)
+        return path6;
+      var groups = path6.source.match(/\((?!\?)/g);
+      if (groups) {
+        for (var i = 0; i < groups.length; i++) {
+          keys.push({
+            name: i,
+            prefix: "",
+            suffix: "",
+            modifier: "",
+            pattern: ""
+          });
         }
       }
-      return void 0;
+      return path6;
     }
-    async function readVercelConfig(fs5) {
-      const hasVercelJson = await fs5.hasPath("vercel.json");
-      if (!hasVercelJson) {
-        return { config: null, error: null };
+    function arrayToRegexp(paths, keys, options) {
+      var parts = paths.map(function(path6) {
+        return pathToRegexp(path6, keys, options).source;
+      });
+      return new RegExp("(?:" + parts.join("|") + ")", flags(options));
+    }
+    function stringToRegexp(path6, keys, options) {
+      return tokensToRegexp(parse(path6, options), keys, options);
+    }
+    function tokensToRegexp(tokens, keys, options) {
+      if (options === void 0) {
+        options = {};
       }
-      try {
-        const content = await fs5.readFile("vercel.json");
-        const config = JSON.parse(content.toString());
-        return { config, error: null };
-      } catch {
-        return {
-          config: null,
-          error: {
-            code: "INVALID_VERCEL_JSON",
-            message: "Failed to parse vercel.json. Ensure it contains valid JSON."
+      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));
+    }
+    exports2.tokensToRegexp = tokensToRegexp;
+    function pathToRegexp(path6, keys, options) {
+      if (path6 instanceof RegExp)
+        return regexpToRegexp(path6, keys);
+      if (Array.isArray(path6))
+        return arrayToRegexp(path6, keys, options);
+      return stringToRegexp(path6, keys, options);
     }
+    exports2.pathToRegexp = pathToRegexp;
   }
 });
 
-// ../fs-detectors/dist/services/resolve.js
-var require_resolve = __commonJS({
-  "../fs-detectors/dist/services/resolve.js"(exports2, module2) {
+// ../../node_modules/.pnpm/path-to-regexp@6.3.0/node_modules/path-to-regexp/dist/index.js
+var require_dist5 = __commonJS({
+  "../../node_modules/.pnpm/path-to-regexp@6.3.0/node_modules/path-to-regexp/dist/index.js"(exports2) {
     "use strict";
-    var __create2 = Object.create;
-    var __defProp2 = Object.defineProperty;
-    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames2 = Object.getOwnPropertyNames;
-    var __getProtoOf2 = Object.getPrototypeOf;
-    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 __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
-      // If the importer is in node compatibility mode or this is not an ESM
-      // file that has been converted to a CommonJS file using a Babel-
-      // compatible transform (i.e. "__esModule" has not been set), then set
-      // "default" to the CommonJS "module.exports" for node compatibility.
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.pathToRegexp = exports2.tokensToRegexp = exports2.regexpToFunction = exports2.match = exports2.tokensToFunction = exports2.compile = exports2.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 parse(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 path6 = "";
+      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) {
+            path6 += prefix;
+            prefix = "";
+          }
+          if (path6) {
+            result.push(path6);
+            path6 = "";
+          }
+          result.push({
+            name: name || key++,
+            prefix,
+            suffix: "",
+            pattern: pattern || safePattern(prefix),
+            modifier: tryConsume("MODIFIER") || ""
+          });
+          continue;
+        }
+        var value = char || tryConsume("ESCAPED_CHAR");
+        if (value) {
+          path6 += value;
+          continue;
+        }
+        if (path6) {
+          result.push(path6);
+          path6 = "";
+        }
+        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;
+    }
+    exports2.parse = parse;
+    function compile(str, options) {
+      return tokensToFunction(parse(str, options), options);
+    }
+    exports2.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 path6 = "";
+        for (var i = 0; i < tokens.length; i++) {
+          var token = tokens[i];
+          if (typeof token === "string") {
+            path6 += 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, '"'));
+              }
+              path6 += 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, '"'));
+            }
+            path6 += 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 path6;
+      };
+    }
+    exports2.tokensToFunction = tokensToFunction;
+    function match(str, options) {
+      var keys = [];
+      var re = pathToRegexp(str, keys, options);
+      return regexpToFunction(re, keys, options);
+    }
+    exports2.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 path6 = 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: path6, index, params };
+      };
+    }
+    exports2.regexpToFunction = regexpToFunction;
+    function escapeString(str) {
+      return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, "\\$1");
+    }
+    function flags(options) {
+      return options && options.sensitive ? "" : "i";
+    }
+    function regexpToRegexp(path6, keys) {
+      if (!keys)
+        return path6;
+      var groupsRegex = /\((?:\?<(.*?)>)?(?!\?)/g;
+      var index = 0;
+      var execResult = groupsRegex.exec(path6.source);
+      while (execResult) {
+        keys.push({
+          // Use parenthesized substring match if available, index otherwise
+          name: execResult[1] || index++,
+          prefix: "",
+          suffix: "",
+          modifier: "",
+          pattern: ""
+        });
+        execResult = groupsRegex.exec(path6.source);
+      }
+      return path6;
+    }
+    function arrayToRegexp(paths, keys, options) {
+      var parts = paths.map(function(path6) {
+        return pathToRegexp(path6, keys, options).source;
+      });
+      return new RegExp("(?:".concat(parts.join("|"), ")"), flags(options));
+    }
+    function stringToRegexp(path6, keys, options) {
+      return tokensToRegexp(parse(path6, 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));
+    }
+    exports2.tokensToRegexp = tokensToRegexp;
+    function pathToRegexp(path6, keys, options) {
+      if (path6 instanceof RegExp)
+        return regexpToRegexp(path6, keys);
+      if (Array.isArray(path6))
+        return arrayToRegexp(path6, keys, options);
+      return stringToRegexp(path6, keys, options);
+    }
+    exports2.pathToRegexp = pathToRegexp;
+  }
+});
+
+// ../routing-utils/dist/superstatic.js
+var require_superstatic = __commonJS({
+  "../routing-utils/dist/superstatic.js"(exports2, 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,
+      convertCleanUrls: () => convertCleanUrls,
+      convertHeaders: () => convertHeaders,
+      convertRedirects: () => convertRedirects,
+      convertRewrites: () => convertRewrites,
+      convertTrailingSlash: () => convertTrailingSlash,
+      getCleanUrls: () => getCleanUrls2,
+      pathToRegexp: () => pathToRegexp,
+      sourceToRegex: () => sourceToRegex2
+    });
+    module2.exports = __toCommonJS2(superstatic_exports);
+    var import_url = require("url");
+    var import_path_to_regexp = require_dist4();
+    var import_path_to_regexp_updated = require_dist5();
+    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 pathToRegexp(callerId, path6, keys, options) {
+      const newKeys = cloneKeys(keys);
+      const currentRegExp = (0, import_path_to_regexp.pathToRegexp)(path6, keys, options);
+      try {
+        const currentKeys = keys;
+        const newRegExp = (0, import_path_to_regexp_updated.pathToRegexp)(path6, newKeys, options);
+        const isDiffRegExp = currentRegExp.toString() !== newRegExp.toString();
+        if (process.env.FORCE_PATH_TO_REGEXP_LOG || isDiffRegExp) {
+          const message = JSON.stringify({
+            path: path6,
+            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: path6,
+          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 convertRewrites(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 dest = replaceSegments(
+            segments,
+            hasSegments,
+            r.destination,
+            false,
+            internalParamNames
+          );
+          const route = { src, dest, check: true };
+          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 = pathToRegexp("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, ":");
+    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 {
+        pathToRegexp("528", pathname, pathnameKeys);
+        pathToRegexp("834", hash || "", hashKeys);
+        pathToRegexp("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"(exports2, 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_dist6();
+    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"(exports2, 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_dist6();
+    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((path6) => {
+        const br = builderRoutes[path6];
+        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"(exports2, 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"(exports2, 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, {
+      bulkRedirectsSchema: () => bulkRedirectsSchema,
+      cleanUrlsSchema: () => cleanUrlsSchema,
+      hasSchema: () => hasSchema,
+      headersSchema: () => headersSchema,
+      redirectsSchema: () => redirectsSchema,
+      rewritesSchema: () => rewritesSchema,
+      routesSchema: () => routesSchema,
+      trailingSlashSchema: () => trailingSlashSchema
+    });
+    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 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 the query parameters of a request or HTTP headers of request or response",
+      type: "array",
+      minItems: 1,
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["type", "op", "target"],
+        properties: {
+          type: {
+            description: "The scope of the transform to apply",
+            type: "string",
+            enum: ["request.headers", "request.query", "response.headers"]
+          },
+          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"]
+                }
+              }
+            },
+            then: {
+              required: ["args"]
+            }
+          },
+          {
+            if: {
+              allOf: [
+                {
+                  properties: {
+                    type: {
+                      enum: ["request.headers", "response.headers"]
+                    }
+                  }
+                },
+                {
+                  properties: {
+                    op: {
+                      enum: ["set", "append"]
+                    }
+                  }
+                }
+              ]
+            },
+            then: {
+              properties: {
+                target: {
+                  properties: {
+                    key: {
+                      if: {
+                        type: "string"
+                      },
+                      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_ :;.,\"'?!(){}\\[\\]@<>=+*#$&`|~\\^%/-]+$"
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        ]
+      }
+    };
+    var routesSchema = {
+      type: "array",
+      deprecated: true,
+      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",
+            required: ["src"],
+            additionalProperties: false,
+            properties: {
+              src: {
+                type: "string",
+                maxLength: 4096
+              },
+              dest: {
+                type: "string",
+                maxLength: 4096
+              },
+              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: {
+                type: "boolean"
+              },
+              user: {
+                type: "boolean"
+              },
+              continue: {
+                type: "boolean"
+              },
+              override: {
+                type: "boolean"
+              },
+              check: {
+                type: "boolean"
+              },
+              isInternal: {
+                type: "boolean"
+              },
+              status: {
+                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",
+            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 or an external URL.",
+            type: "string",
+            maxLength: 4096
+          },
+          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).",
+            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"
+    };
+    var bulkRedirectsSchema = {
+      type: "array",
+      description: "A list of bulk redirect definitions.",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        required: ["source", "destination"],
+        properties: {
+          source: {
+            description: "The exact URL path or pattern to match.",
+            type: "string",
+            maxLength: 2048
+          },
+          destination: {
+            description: "The target URL path where traffic should be redirected.",
+            type: "string",
+            maxLength: 2048
+          },
+          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.",
+            type: "integer",
+            enum: [301, 302, 307, 308]
+          },
+          sensitive: {
+            description: "A boolean to toggle between case-sensitive and case-insensitive redirect. When `true`, the redirect is case-sensitive. When `false` the redirect is case-insensitive.",
+            type: "boolean"
+          },
+          query: {
+            description: "Whether the query string should be preserved by the redirect. The default is `false`.",
+            type: "boolean"
+          }
+        }
+      }
+    };
+  }
+});
+
+// ../routing-utils/dist/types.js
+var require_types2 = __commonJS({
+  "../routing-utils/dist/types.js"(exports2, 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_dist6 = __commonJS({
+  "../routing-utils/dist/index.js"(exports2, 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,
+      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,
+      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_types2(), 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 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);
+        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);
+          }
+          const handleValue = handling[handling.length - 1];
+          if (handleValue === "hit") {
+            if (route.dest) {
+              errors.push(
+                `Route at index ${i} cannot define \`dest\` after \`handle: hit\`.`
+              );
+            }
+            if (route.status) {
+              errors.push(
+                `Route at index ${i} cannot define \`status\` 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 \`handle\` or \`src\` 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";
+        return `${type} at index ${index} has invalid \`${prop}\` regular expression "${src}".`;
+      }
+      return null;
+    }
+    function checkPatternSyntax(type, index, {
+      source,
+      destination,
+      has
+    }) {
+      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"
+        };
+      }
+      if (destination) {
+        try {
+          const { hostname, pathname, query } = (0, import_url.parse)(destination, 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"
+            };
+          }
+        }
+      }
+      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;
+      let { routes = null } = vercelConfig;
+      if (routes) {
+        const hasNewProperties = typeof cleanUrls !== "undefined" || typeof trailingSlash !== "undefined" || typeof redirects !== "undefined" || typeof headers !== "undefined" || typeof rewrites !== "undefined";
+        if (hasNewProperties) {
+          const error = createError(
+            "invalid_mixed_routes",
+            "If `rewrites`, `redirects`, `headers`, `cleanUrls` or `trailingSlash` are used, then `routes` cannot be present.",
+            "https://vercel.link/mix-routing-props",
+            "Learn More"
+          );
+          return { routes, error };
+        }
+        return normalizeRoutes(routes);
+      }
+      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 (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 };
+    }
+  }
+});
+
+// ../fs-detectors/dist/services/types.js
+var require_types3 = __commonJS({
+  "../fs-detectors/dist/services/types.js"(exports2, 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 types_exports = {};
+    __export2(types_exports, {
+      ENTRYPOINT_EXTENSIONS: () => ENTRYPOINT_EXTENSIONS,
+      ROUTE_OWNING_BUILDERS: () => ROUTE_OWNING_BUILDERS,
+      RUNTIME_BUILDERS: () => RUNTIME_BUILDERS,
+      RUNTIME_MANIFESTS: () => RUNTIME_MANIFESTS,
+      STATIC_BUILDERS: () => STATIC_BUILDERS
+    });
+    module2.exports = __toCommonJS2(types_exports);
+    var RUNTIME_BUILDERS = {
+      node: "@vercel/node",
+      python: "@vercel/python",
+      go: "@vercel/go",
+      rust: "@vercel/rust",
+      ruby: "@vercel/ruby"
+    };
+    var RUNTIME_MANIFESTS = {
+      node: ["package.json"],
+      python: [
+        "pyproject.toml",
+        "requirements.txt",
+        "Pipfile",
+        "pylock.yml",
+        "uv.lock",
+        "setup.py"
+      ],
+      go: ["go.mod"],
+      ruby: ["Gemfile"],
+      rust: ["Cargo.toml"]
+    };
+    var ENTRYPOINT_EXTENSIONS = {
+      ".ts": "node",
+      ".mts": "node",
+      ".js": "node",
+      ".mjs": "node",
+      ".cjs": "node",
+      ".py": "python",
+      ".go": "go",
+      ".rs": "rust",
+      ".rb": "ruby",
+      ".ru": "ruby"
+    };
+    var STATIC_BUILDERS = /* @__PURE__ */ new Set([
+      "@vercel/static-build",
+      "@vercel/static"
+    ]);
+    var ROUTE_OWNING_BUILDERS = /* @__PURE__ */ new Set([
+      "@vercel/next",
+      "@vercel/backends"
+    ]);
+  }
+});
+
+// ../fs-detectors/dist/services/utils.js
+var require_utils4 = __commonJS({
+  "../fs-detectors/dist/services/utils.js"(exports2, 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 utils_exports = {};
+    __export2(utils_exports, {
+      INTERNAL_SERVICE_PREFIX: () => INTERNAL_SERVICE_PREFIX2,
+      getBuilderForRuntime: () => getBuilderForRuntime,
+      getInternalServiceFunctionPath: () => getInternalServiceFunctionPath2,
+      hasFile: () => hasFile,
+      inferServiceRuntime: () => inferServiceRuntime,
+      isRouteOwningBuilder: () => isRouteOwningBuilder2,
+      isStaticBuild: () => isStaticBuild2,
+      readVercelConfig: () => readVercelConfig
+    });
+    module2.exports = __toCommonJS2(utils_exports);
+    var import_framework_helpers = require("@vercel/build-utils/dist/framework-helpers");
+    var import_types = require_types3();
+    async function hasFile(fs5, filePath) {
+      try {
+        return await fs5.isFile(filePath);
+      } catch {
+        return false;
+      }
+    }
+    var INTERNAL_SERVICE_PREFIX2 = "/_svc";
+    function getInternalServiceFunctionPath2(serviceName) {
+      return `${INTERNAL_SERVICE_PREFIX2}/${serviceName}/index`;
+    }
+    function getBuilderForRuntime(runtime) {
+      const builder = import_types.RUNTIME_BUILDERS[runtime];
+      if (!builder) {
+        throw new Error(`Unknown runtime: ${runtime}`);
+      }
+      return builder;
+    }
+    function isStaticBuild2(service) {
+      return import_types.STATIC_BUILDERS.has(service.builder.use);
+    }
+    function isRouteOwningBuilder2(service) {
+      return import_types.ROUTE_OWNING_BUILDERS.has(service.builder.use);
+    }
+    function inferServiceRuntime(config) {
+      if (config.runtime && config.runtime in import_types.RUNTIME_BUILDERS) {
+        return config.runtime;
+      }
+      if ((0, import_framework_helpers.isPythonFramework)(config.framework)) {
+        return "python";
+      }
+      if ((0, import_framework_helpers.isBackendFramework)(config.framework)) {
+        return "node";
+      }
+      if (config.builder) {
+        for (const [runtime, builderName] of Object.entries(import_types.RUNTIME_BUILDERS)) {
+          if (config.builder === builderName) {
+            return runtime;
+          }
+        }
+      }
+      if (config.entrypoint) {
+        for (const [ext, runtime] of Object.entries(import_types.ENTRYPOINT_EXTENSIONS)) {
+          if (config.entrypoint.endsWith(ext)) {
+            return runtime;
+          }
+        }
+      }
+      return void 0;
+    }
+    async function readVercelConfig(fs5) {
+      const hasVercelJson = await fs5.hasPath("vercel.json");
+      if (!hasVercelJson) {
+        return { config: null, error: null };
+      }
+      try {
+        const content = await fs5.readFile("vercel.json");
+        const config = JSON.parse(content.toString());
+        return { config, error: null };
+      } catch {
+        return {
+          config: null,
+          error: {
+            code: "INVALID_VERCEL_JSON",
+            message: "Failed to parse vercel.json. Ensure it contains valid JSON."
+          }
+        };
+      }
+    }
+  }
+});
+
+// ../fs-detectors/dist/services/resolve.js
+var require_resolve = __commonJS({
+  "../fs-detectors/dist/services/resolve.js"(exports2, module2) {
+    "use strict";
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    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 __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
       isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
       mod
     ));
@@ -19920,17 +22466,70 @@ var require_resolve = __commonJS({
     });
     module2.exports = __toCommonJS2(resolve_exports);
     var import_path7 = require("path");
-    var import_types = require_types2();
+    var import_types = require_types3();
     var import_utils = require_utils4();
     var import_frameworks2 = __toESM2(require_frameworks());
+    var import_routing_utils = require_dist6();
     var frameworksBySlug = new Map(import_frameworks2.default.map((f) => [f.slug, f]));
     var SERVICE_NAME_REGEX = /^[a-zA-Z]([a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;
-    function normalizeRoutePrefix(routePrefix) {
-      let normalized = routePrefix.startsWith("/") ? routePrefix : `/${routePrefix}`;
-      if (normalized !== "/" && normalized.endsWith("/")) {
-        normalized = normalized.slice(0, -1);
+    function toWorkspaceRelativeEntrypoint(entrypoint, workspace) {
+      const normalizedEntrypoint = import_path7.posix.normalize(entrypoint);
+      if (workspace === ".") {
+        return normalizedEntrypoint;
       }
-      return normalized || "/";
+      const workspacePrefix = `${workspace}/`;
+      if (normalizedEntrypoint.startsWith(workspacePrefix)) {
+        return normalizedEntrypoint.slice(workspacePrefix.length);
+      }
+      const relativeEntrypoint = import_path7.posix.relative(
+        workspace,
+        normalizedEntrypoint
+      );
+      if (relativeEntrypoint === "" || relativeEntrypoint.startsWith("..")) {
+        return normalizedEntrypoint;
+      }
+      return relativeEntrypoint;
+    }
+    async function inferWorkspaceFromNearestManifest({
+      fs: fs5,
+      entrypoint,
+      runtime
+    }) {
+      if (!entrypoint || !runtime) {
+        return void 0;
+      }
+      const manifests = import_types.RUNTIME_MANIFESTS[runtime];
+      if (!manifests || manifests.length === 0) {
+        return void 0;
+      }
+      let dir = import_path7.posix.dirname(import_path7.posix.normalize(entrypoint)) || ".";
+      if (dir === "") {
+        dir = ".";
+      }
+      let reachedRoot = false;
+      while (!reachedRoot) {
+        for (const manifest of manifests) {
+          const manifestPath = dir === "." ? manifest : import_path7.posix.join(dir, manifest);
+          if (await (0, import_utils.hasFile)(fs5, manifestPath)) {
+            return dir;
+          }
+        }
+        if (dir === "." || dir === "/") {
+          reachedRoot = true;
+        } else {
+          const parent = import_path7.posix.dirname(dir);
+          if (!parent || parent === dir) {
+            reachedRoot = true;
+          } else {
+            dir = parent;
+          }
+        }
+      }
+      return void 0;
+    }
+    function isReservedServiceRoutePrefix(routePrefix) {
+      const normalized = (0, import_routing_utils.normalizeRoutePrefix)(routePrefix);
+      return normalized === import_utils.INTERNAL_SERVICE_PREFIX || normalized.startsWith(`${import_utils.INTERNAL_SERVICE_PREFIX}/`);
     }
     function validateServiceConfig(name, config) {
       if (!SERVICE_NAME_REGEX.test(name)) {
@@ -19955,6 +22554,13 @@ var require_resolve = __commonJS({
           serviceName: name
         };
       }
+      if (serviceType === "web" && config.routePrefix && isReservedServiceRoutePrefix(config.routePrefix)) {
+        return {
+          code: "RESERVED_ROUTE_PREFIX",
+          message: `Web service "${name}" cannot use routePrefix "${config.routePrefix}". The "${import_utils.INTERNAL_SERVICE_PREFIX}" prefix is reserved for internal services routing.`,
+          serviceName: name
+        };
+      }
       if ((serviceType === "worker" || serviceType === "cron") && config.routePrefix) {
         return {
           code: "INVALID_ROUTE_PREFIX",
@@ -20013,24 +22619,41 @@ var require_resolve = __commonJS({
       }
       return null;
     }
-    function resolveConfiguredService(name, config, group) {
+    async function resolveConfiguredService(name, config, fs5, group) {
       const type = config.type || "web";
-      const workspace = config.workspace || ".";
+      const inferredRuntime = (0, import_utils.inferServiceRuntime)(config);
+      let workspace = config.workspace || ".";
+      let resolvedEntrypoint = config.entrypoint;
+      if (!config.workspace) {
+        const inferredWorkspace = await inferWorkspaceFromNearestManifest({
+          fs: fs5,
+          entrypoint: resolvedEntrypoint,
+          runtime: inferredRuntime
+        });
+        if (inferredWorkspace) {
+          workspace = inferredWorkspace;
+          if (resolvedEntrypoint) {
+            resolvedEntrypoint = toWorkspaceRelativeEntrypoint(
+              resolvedEntrypoint,
+              inferredWorkspace
+            );
+          }
+        }
+      }
       const topic = type === "worker" ? config.topic || "default" : config.topic;
       const consumer = type === "worker" ? config.consumer || "default" : config.consumer;
-      const inferredRuntime = (0, import_utils.inferServiceRuntime)(config);
       let builderUse;
       let builderSrc;
       if (config.framework) {
         const framework = frameworksBySlug.get(config.framework);
         builderUse = framework?.useRuntime?.use || "@vercel/static-build";
-        builderSrc = config.entrypoint || framework?.useRuntime?.src || "package.json";
+        builderSrc = resolvedEntrypoint || framework?.useRuntime?.src || "package.json";
       } else if (config.builder) {
         builderUse = config.builder;
-        builderSrc = config.entrypoint;
+        builderSrc = resolvedEntrypoint;
       } else {
         builderUse = (0, import_utils.getBuilderForRuntime)(inferredRuntime);
-        builderSrc = config.entrypoint;
+        builderSrc = resolvedEntrypoint;
       }
       const routePrefix = type === "web" && config.routePrefix ? config.routePrefix.startsWith("/") ? config.routePrefix : `/${config.routePrefix}` : void 0;
       const isRoot = workspace === ".";
@@ -20063,7 +22686,7 @@ var require_resolve = __commonJS({
         type,
         group,
         workspace,
-        entrypoint: config.entrypoint,
+        entrypoint: resolvedEntrypoint,
         routePrefix,
         framework: config.framework,
         builder: {
@@ -20079,7 +22702,7 @@ var require_resolve = __commonJS({
         consumer
       };
     }
-    function resolveAllConfiguredServices(services) {
+    async function resolveAllConfiguredServices(services, fs5) {
       const resolved = [];
       const errors = [];
       const webServicesByRoutePrefix = /* @__PURE__ */ new Map();
@@ -20090,9 +22713,9 @@ var require_resolve = __commonJS({
           errors.push(validationError);
           continue;
         }
-        const service = resolveConfiguredService(name, serviceConfig);
+        const service = await resolveConfiguredService(name, serviceConfig, fs5);
         if (service.type === "web" && typeof service.routePrefix === "string") {
-          const normalizedRoutePrefix = normalizeRoutePrefix(service.routePrefix);
+          const normalizedRoutePrefix = (0, import_routing_utils.normalizeRoutePrefix)(service.routePrefix);
           const existingServiceName = webServicesByRoutePrefix.get(
             normalizedRoutePrefix
           );
@@ -20622,7 +23245,7 @@ var require_detect_services = __commonJS({
       generateServicesRoutes: () => generateServicesRoutes2
     });
     module2.exports = __toCommonJS2(detect_services_exports);
-    var import_types = require_types2();
+    var import_routing_utils = require_dist6();
     var import_utils = require_utils4();
     var import_resolve = require_resolve();
     var import_auto_detect = require_auto_detect();
@@ -20651,7 +23274,10 @@ var require_detect_services = __commonJS({
           };
         }
         if (autoResult.services) {
-          const result2 = (0, import_resolve.resolveAllConfiguredServices)(autoResult.services);
+          const result2 = await (0, import_resolve.resolveAllConfiguredServices)(
+            autoResult.services,
+            scopedFs
+          );
           const routes2 = generateServicesRoutes2(result2.services);
           return {
             services: result2.services,
@@ -20672,7 +23298,10 @@ var require_detect_services = __commonJS({
           warnings: []
         };
       }
-      const result = (0, import_resolve.resolveAllConfiguredServices)(configuredServices);
+      const result = await (0, import_resolve.resolveAllConfiguredServices)(
+        configuredServices,
+        scopedFs
+      );
       const routes = generateServicesRoutes2(result.services);
       return {
         services: result.services,
@@ -20686,45 +23315,47 @@ var require_detect_services = __commonJS({
       const defaults = [];
       const crons = [];
       const workers = [];
-      const entrypointExtensions = Object.keys(import_types.ENTRYPOINT_EXTENSIONS).sort(
-        (a, b) => b.length - a.length
-      );
-      const stripEntrypointExtension = (entrypoint) => {
-        for (const ext of entrypointExtensions) {
-          if (entrypoint.endsWith(ext)) {
-            return entrypoint.slice(0, -ext.length);
-          }
-        }
-        return entrypoint;
-      };
       const sortedWebServices = services.filter(
         (s) => s.type === "web" && typeof s.routePrefix === "string"
       ).sort((a, b) => b.routePrefix.length - a.routePrefix.length);
+      const allWebPrefixes = getWebRoutePrefixes(sortedWebServices);
       for (const service of sortedWebServices) {
         const { routePrefix } = service;
         const normalizedPrefix = routePrefix.slice(1);
+        const ownershipGuard = (0, import_routing_utils.getOwnershipGuard)(routePrefix, allWebPrefixes);
         if ((0, import_utils.isRouteOwningBuilder)(service)) {
           continue;
         }
         if ((0, import_utils.isStaticBuild)(service)) {
           if (routePrefix === "/") {
             defaults.push({ handle: "filesystem" });
-            defaults.push({ src: "/(.*)", dest: "/index.html" });
+            defaults.push({
+              src: (0, import_routing_utils.scopeRouteSourceToOwnership)("/(.*)", ownershipGuard),
+              dest: "/index.html"
+            });
           } else {
             rewrites.push({
-              src: `^/${normalizedPrefix}(?:/.*)?$`,
+              src: (0, import_routing_utils.scopeRouteSourceToOwnership)(
+                `^/${normalizedPrefix}(?:/.*)?$`,
+                ownershipGuard
+              ),
               dest: `/${normalizedPrefix}/index.html`
             });
           }
         } else if (service.runtime) {
-          const builderSrc = service.builder.src || routePrefix;
-          const extensionless = stripEntrypointExtension(builderSrc);
-          const functionPath = extensionless.startsWith("/") ? extensionless : `/${extensionless}`;
+          const functionPath = (0, import_utils.getInternalServiceFunctionPath)(service.name);
           if (routePrefix === "/") {
-            defaults.push({ src: "^/(.*)$", dest: functionPath, check: true });
+            defaults.push({
+              src: (0, import_routing_utils.scopeRouteSourceToOwnership)("^/(.*)$", ownershipGuard),
+              dest: functionPath,
+              check: true
+            });
           } else {
             rewrites.push({
-              src: `^/${normalizedPrefix}(?:/.*)?$`,
+              src: (0, import_routing_utils.scopeRouteSourceToOwnership)(
+                `^/${normalizedPrefix}(?:/.*)?$`,
+                ownershipGuard
+              ),
               dest: functionPath,
               check: true
             });
@@ -20735,6 +23366,16 @@ var require_detect_services = __commonJS({
       }
       return { rewrites, defaults, crons, workers };
     }
+    function getWebRoutePrefixes(services) {
+      const unique = /* @__PURE__ */ new Set();
+      for (const service of services) {
+        if (service.type !== "web" || typeof service.routePrefix !== "string") {
+          continue;
+        }
+        unique.add((0, import_routing_utils.normalizeRoutePrefix)(service.routePrefix));
+      }
+      return Array.from(unique);
+    }
   }
 });
 
@@ -21899,7 +24540,7 @@ var require_detect_file_system_api = __commonJS({
     });
     module2.exports = __toCommonJS2(detect_file_system_api_exports);
     var import_semver2 = __toESM2(require_semver3());
-    var import__ = require_dist4();
+    var import__ = require_dist7();
     async function detectFileSystemAPI2({
       files,
       projectSettings,
@@ -23104,7 +25745,7 @@ var require_timestamp2 = __commonJS({
 });
 
 // ../../node_modules/.pnpm/js-yaml@4.1.0/node_modules/js-yaml/lib/type/merge.js
-var require_merge2 = __commonJS({
+var require_merge3 = __commonJS({
   "../../node_modules/.pnpm/js-yaml@4.1.0/node_modules/js-yaml/lib/type/merge.js"(exports2, module2) {
     "use strict";
     var Type = require_type2();
@@ -23326,7 +25967,7 @@ var require_default = __commonJS({
     module2.exports = require_core2().extend({
       implicit: [
         require_timestamp2(),
-        require_merge2()
+        require_merge3()
       ],
       explicit: [
         require_binary2(),
@@ -25177,7 +27818,7 @@ var require_js_yaml3 = __commonJS({
       timestamp: require_timestamp2(),
       bool: require_bool2(),
       int: require_int2(),
-      merge: require_merge2(),
+      merge: require_merge3(),
       omap: require_omap2(),
       seq: require_seq2(),
       str: require_str2()
@@ -29262,7 +31903,7 @@ var require_detect_instrumentation = __commonJS({
 });
 
 // ../fs-detectors/dist/index.js
-var require_dist4 = __commonJS({
+var require_dist7 = __commonJS({
   "../fs-detectors/dist/index.js"(exports2, module2) {
     "use strict";
     var __defProp2 = Object.defineProperty;
@@ -29288,6 +31929,7 @@ var require_dist4 = __commonJS({
       DetectorFilesystem: () => import_filesystem.DetectorFilesystem,
       GetWorkspaceOptions: () => import_get_workspaces.GetWorkspaceOptions,
       GetWorkspacePackagePathsOptions: () => import_get_workspace_package_paths.GetWorkspacePackagePathsOptions,
+      INTERNAL_SERVICE_PREFIX: () => import_utils.INTERNAL_SERVICE_PREFIX,
       LocalFileSystemDetector: () => import_local_file_system_detector.LocalFileSystemDetector,
       REGEX_NON_VERCEL_PLATFORM_FILES: () => import_detect_builders2.REGEX_NON_VERCEL_PLATFORM_FILES,
       Workspace: () => import_get_workspaces.Workspace,
@@ -29305,6 +31947,7 @@ var require_dist4 = __commonJS({
       detectOutputDirectory: () => import_detect_builders.detectOutputDirectory,
       detectServices: () => import_detect_services.detectServices,
       generateServicesRoutes: () => import_detect_services.generateServicesRoutes,
+      getInternalServiceFunctionPath: () => import_utils.getInternalServiceFunctionPath,
       getProjectPaths: () => import_get_project_paths.getProjectPaths,
       getServicesBuilders: () => import_get_services_builders.getServicesBuilders,
       getWorkspacePackagePaths: () => import_get_workspace_package_paths.getWorkspacePackagePaths,
@@ -29562,6 +32205,9 @@ function parseFunctionConfig(data) {
   if (Array.isArray(data.regions) && data.regions.every((r) => typeof r === "string")) {
     config.regions = data.regions;
   }
+  if (Array.isArray(data.functionFailoverRegions) && data.functionFailoverRegions.every((r) => typeof r === "string")) {
+    config.functionFailoverRegions = data.functionFailoverRegions;
+  }
   return config;
 }
 async function readBuildOutputConfig({
@@ -30143,7 +32789,7 @@ async function injectVercelAnalyticsPlugin(dir) {
 
 // src/index.ts
 var import_tree_kill = __toESM(require_tree_kill());
-var import_fs_detectors = __toESM(require_dist4());
+var import_fs_detectors = __toESM(require_dist7());
 
 // src/utils/hugo.ts
 var import_node_fetch = __toESM(require_lib2());