@vercel/static-build 2.8.28 → 2.8.29

package/dist/index.js

@@ -11994,6 +11994,150 @@ var require_frameworks = __commonJS({
           }
         ]
       },
+      {
+        name: "Ruby",
+        slug: "ruby",
+        experimental: true,
+        runtimeFramework: true,
+        logo: "https://api-frameworks.vercel.sh/framework-logos/ruby.svg",
+        tagline: "A dynamic, open source programming language with a focus on simplicity and productivity.",
+        description: "A generic Ruby application deployed as a serverless function.",
+        website: "https://www.ruby-lang.org",
+        useRuntime: { src: "config.ru", use: "@vercel/ruby" },
+        ignoreRuntimes: ["@vercel/ruby"],
+        detectors: {
+          every: [
+            {
+              path: "config.ru"
+            },
+            {
+              path: "Gemfile"
+            }
+          ]
+        },
+        settings: {
+          installCommand: {
+            placeholder: "`bundle install`"
+          },
+          buildCommand: {
+            placeholder: "None",
+            value: null
+          },
+          devCommand: {
+            placeholder: "None",
+            value: null
+          },
+          outputDirectory: {
+            value: "N/A"
+          }
+        },
+        getOutputDirName: async () => "public",
+        defaultRoutes: [
+          {
+            handle: "filesystem"
+          },
+          {
+            src: "/(.*)",
+            dest: "/config"
+          }
+        ]
+      },
+      {
+        name: "Rust",
+        slug: "rust",
+        experimental: true,
+        runtimeFramework: true,
+        logo: "https://api-frameworks.vercel.sh/framework-logos/rust.svg",
+        tagline: "A language empowering everyone to build reliable and efficient software.",
+        description: "A generic Rust application deployed as a serverless function.",
+        website: "https://www.rust-lang.org",
+        useRuntime: { src: "src/main.rs", use: "@vercel/rust" },
+        ignoreRuntimes: ["@vercel/rust"],
+        detectors: {
+          every: [
+            {
+              path: "Cargo.toml"
+            },
+            {
+              path: "src/main.rs"
+            }
+          ]
+        },
+        settings: {
+          installCommand: {
+            placeholder: "None"
+          },
+          buildCommand: {
+            placeholder: "None",
+            value: null
+          },
+          devCommand: {
+            placeholder: "`cargo run`",
+            value: null
+          },
+          outputDirectory: {
+            value: "N/A"
+          }
+        },
+        getOutputDirName: async () => "public",
+        defaultRoutes: [
+          {
+            handle: "filesystem"
+          },
+          {
+            src: "/(.*)",
+            dest: "/src/main"
+          }
+        ]
+      },
+      {
+        name: "Node",
+        slug: "node",
+        experimental: true,
+        runtimeFramework: true,
+        logo: "https://api-frameworks.vercel.sh/framework-logos/node.svg",
+        tagline: "Node.js is a JavaScript runtime built on Chrome's V8 JavaScript engine.",
+        description: "A generic Node.js application deployed as a serverless function.",
+        website: "https://nodejs.org",
+        useRuntime: { src: "server.ts", use: "@vercel/backends" },
+        ignoreRuntimes: ["@vercel/node"],
+        detectors: {
+          every: [
+            {
+              path: "server.ts"
+            },
+            {
+              path: "package.json"
+            }
+          ]
+        },
+        settings: {
+          installCommand: {
+            placeholder: "`yarn install`, `pnpm install`, `npm install`, or `bun install`"
+          },
+          buildCommand: {
+            placeholder: "None",
+            value: null
+          },
+          devCommand: {
+            placeholder: "`npm run dev` or `npx ts-node server.ts`",
+            value: null
+          },
+          outputDirectory: {
+            value: "N/A"
+          }
+        },
+        getOutputDirName: async () => "public",
+        defaultRoutes: [
+          {
+            handle: "filesystem"
+          },
+          {
+            src: "/(.*)",
+            dest: "/"
+          }
+        ]
+      },
       {
         name: "Services",
         slug: "services",
@@ -19530,9 +19674,148 @@ var require_is_official_runtime = __commonJS({
   }
 });
 
-// ../fs-detectors/dist/detect-builders.js
-var require_detect_builders = __commonJS({
-  "../fs-detectors/dist/detect-builders.js"(exports2, module2) {
+// ../fs-detectors/dist/services/types.js
+var require_types2 = __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,
+      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"
+    ]);
+  }
+});
+
+// ../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, {
+      getBuilderForRuntime: () => getBuilderForRuntime,
+      inferServiceRuntime: () => inferServiceRuntime,
+      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}`);
+      }
+      return builder;
+    }
+    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;
@@ -19561,62 +19844,659 @@ var require_detect_builders = __commonJS({
       mod
     ));
     var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
-    var detect_builders_exports = {};
-    __export2(detect_builders_exports, {
-      REGEX_MIDDLEWARE_FILES: () => REGEX_MIDDLEWARE_FILES,
-      REGEX_NON_VERCEL_PLATFORM_FILES: () => REGEX_NON_VERCEL_PLATFORM_FILES2,
-      REGEX_VERCEL_PLATFORM_FILES: () => REGEX_VERCEL_PLATFORM_FILES,
-      detectApiDirectory: () => detectApiDirectory2,
-      detectApiExtensions: () => detectApiExtensions2,
-      detectBuilders: () => detectBuilders2,
-      detectOutputDirectory: () => detectOutputDirectory2,
-      sortFiles: () => sortFiles
+    var resolve_exports = {};
+    __export2(resolve_exports, {
+      resolveAllConfiguredServices: () => resolveAllConfiguredServices,
+      resolveConfiguredService: () => resolveConfiguredService,
+      validateServiceConfig: () => validateServiceConfig
     });
-    module2.exports = __toCommonJS2(detect_builders_exports);
-    var import_minimatch = __toESM2(require_minimatch());
-    var import_semver2 = require_semver3();
+    module2.exports = __toCommonJS2(resolve_exports);
     var import_path7 = require("path");
+    var import_types = require_types2();
+    var import_utils = require_utils4();
     var import_frameworks2 = __toESM2(require_frameworks());
-    var import_is_official_runtime = require_is_official_runtime();
-    var import_build_utils5 = require("@vercel/build-utils");
-    var REGEX_MIDDLEWARE_FILES = "middleware.[jt]s";
-    var REGEX_VERCEL_PLATFORM_FILES = `api/**,package.json,${REGEX_MIDDLEWARE_FILES}`;
-    var REGEX_NON_VERCEL_PLATFORM_FILES2 = `!{${REGEX_VERCEL_PLATFORM_FILES}}`;
-    var slugToFramework = new Map(
-      import_frameworks2.default.map((f) => [f.slug, f])
-    );
-    function sortFiles(fileA, fileB) {
-      return fileA.localeCompare(fileB);
-    }
-    function detectApiExtensions2(builders) {
-      return new Set(
-        builders.filter(
-          (b) => Boolean(b.config && b.config.zeroConfig && b.src?.startsWith("api/"))
-        ).map((b) => (0, import_path7.extname)(b.src)).filter(Boolean)
-      );
-    }
-    function detectApiDirectory2(builders) {
-      const found = builders.some(
-        (b) => b.config && b.config.zeroConfig && b.src?.startsWith("api/")
-      );
-      return found ? "api" : null;
-    }
-    function getPublicBuilder(builders) {
-      for (const builder of builders) {
-        if (typeof builder.src === "string" && (0, import_is_official_runtime.isOfficialRuntime)("static", builder.use) && /^.*\/\*\*\/\*$/.test(builder.src) && builder.config?.zeroConfig === true) {
-          return builder;
-        }
+    var frameworksBySlug = new Map(import_frameworks2.default.map((f) => [f.slug, f]));
+    function validateServiceConfig(name, config) {
+      if (!config || typeof config !== "object") {
+        return {
+          code: "INVALID_SERVICE_CONFIG",
+          message: `Service "${name}" has an invalid configuration. Expected an object.`,
+          serviceName: name
+        };
       }
-      return null;
-    }
-    function detectOutputDirectory2(builders) {
-      const publicBuilder = getPublicBuilder(builders);
-      return publicBuilder ? publicBuilder.src.replace("/**/*", "") : null;
-    }
-    async function detectBuilders2(files, pkg, options = {}) {
-      const errors = [];
-      const warnings = [];
-      let apiBuilders = [];
+      const serviceType = config.type || "web";
+      if (serviceType === "web" && !config.routePrefix) {
+        return {
+          code: "MISSING_ROUTE_PREFIX",
+          message: `Web service "${name}" must specify "routePrefix".`,
+          serviceName: name
+        };
+      }
+      if ((serviceType === "worker" || serviceType === "cron") && config.routePrefix) {
+        return {
+          code: "INVALID_ROUTE_PREFIX",
+          message: `${serviceType === "worker" ? "Worker" : "Cron"} service "${name}" cannot have "routePrefix". Only web services should specify "routePrefix".`,
+          serviceName: name
+        };
+      }
+      if (serviceType === "cron" && !config.schedule) {
+        return {
+          code: "MISSING_CRON_SCHEDULE",
+          message: `Cron service "${name}" is missing required "schedule" field.`,
+          serviceName: name
+        };
+      }
+      if (config.runtime && !(config.runtime in import_types.RUNTIME_BUILDERS)) {
+        return {
+          code: "INVALID_RUNTIME",
+          message: `Service "${name}" has invalid runtime "${config.runtime}".`,
+          serviceName: name
+        };
+      }
+      if (config.framework && !frameworksBySlug.has(config.framework)) {
+        return {
+          code: "INVALID_FRAMEWORK",
+          message: `Service "${name}" has invalid framework "${config.framework}".`,
+          serviceName: name
+        };
+      }
+      const hasFramework = Boolean(config.framework);
+      const hasBuilderOrRuntime = Boolean(config.builder || config.runtime);
+      const hasEntrypoint = Boolean(config.entrypoint);
+      if (!hasFramework && !hasBuilderOrRuntime && !hasEntrypoint) {
+        return {
+          code: "MISSING_SERVICE_CONFIG",
+          message: `Service "${name}" must specify "framework", "entrypoint", or both "builder"/"runtime" with "entrypoint".`,
+          serviceName: name
+        };
+      }
+      if (hasBuilderOrRuntime && !hasFramework && !hasEntrypoint) {
+        return {
+          code: "MISSING_ENTRYPOINT",
+          message: `Service "${name}" must specify "entrypoint" when using "${config.builder ? "builder" : "runtime"}".`,
+          serviceName: name
+        };
+      }
+      if (hasEntrypoint && !hasBuilderOrRuntime && !hasFramework) {
+        const runtime = (0, import_utils.inferServiceRuntime)({ entrypoint: config.entrypoint });
+        if (!runtime) {
+          const supported = Object.keys(import_types.ENTRYPOINT_EXTENSIONS).join(", ");
+          return {
+            code: "UNSUPPORTED_ENTRYPOINT",
+            message: `Service "${name}" has unsupported entrypoint "${config.entrypoint}". Use a supported extension (${supported}) or specify "builder", "framework", or "runtime".`,
+            serviceName: name
+          };
+        }
+      }
+      return null;
+    }
+    function resolveConfiguredService(name, config, group) {
+      const type = config.type || "web";
+      const workspace = config.workspace || ".";
+      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";
+      } else if (config.builder) {
+        builderUse = config.builder;
+        builderSrc = config.entrypoint;
+      } else {
+        builderUse = (0, import_utils.getBuilderForRuntime)(inferredRuntime);
+        builderSrc = config.entrypoint;
+      }
+      const routePrefix = type === "web" ? config.routePrefix : void 0;
+      const isRoot = workspace === ".";
+      if (!isRoot && !builderSrc.startsWith(workspace + "/")) {
+        builderSrc = import_path7.posix.join(workspace, builderSrc);
+      }
+      const builderConfig = {};
+      if (config.memory)
+        builderConfig.memory = config.memory;
+      if (config.maxDuration)
+        builderConfig.maxDuration = config.maxDuration;
+      if (config.includeFiles)
+        builderConfig.includeFiles = config.includeFiles;
+      if (config.excludeFiles)
+        builderConfig.excludeFiles = config.excludeFiles;
+      const isStaticBuild = import_types.STATIC_BUILDERS.has(builderUse);
+      const runtime = isStaticBuild ? void 0 : inferredRuntime;
+      return {
+        name,
+        type,
+        group,
+        workspace,
+        entrypoint: config.entrypoint,
+        routePrefix,
+        framework: config.framework,
+        builder: {
+          src: builderSrc,
+          use: builderUse,
+          config: Object.keys(builderConfig).length > 0 ? builderConfig : void 0
+        },
+        runtime,
+        buildCommand: config.buildCommand,
+        installCommand: config.installCommand,
+        schedule: config.schedule,
+        topic,
+        consumer
+      };
+    }
+    function resolveAllConfiguredServices(services) {
+      const resolved = [];
+      const errors = [];
+      for (const name of Object.keys(services)) {
+        const serviceConfig = services[name];
+        const validationError = validateServiceConfig(name, serviceConfig);
+        if (validationError) {
+          errors.push(validationError);
+          continue;
+        }
+        const service = resolveConfiguredService(name, serviceConfig);
+        resolved.push(service);
+      }
+      return { services: resolved, errors };
+    }
+  }
+});
+
+// ../fs-detectors/dist/services/detect-services.js
+var require_detect_services = __commonJS({
+  "../fs-detectors/dist/services/detect-services.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 detect_services_exports = {};
+    __export2(detect_services_exports, {
+      detectServices: () => detectServices2,
+      generateServicesRoutes: () => generateServicesRoutes2
+    });
+    module2.exports = __toCommonJS2(detect_services_exports);
+    var import_utils = require_utils4();
+    var import_resolve = require_resolve();
+    async function detectServices2(options) {
+      const { fs: fs5, workPath } = options;
+      const scopedFs = workPath ? fs5.chdir(workPath) : fs5;
+      const { config: vercelConfig, error: configError } = await (0, import_utils.readVercelConfig)(scopedFs);
+      if (configError) {
+        return {
+          services: [],
+          routes: { rewrites: [], defaults: [], crons: [], workers: [] },
+          errors: [configError],
+          warnings: []
+        };
+      }
+      const configuredServices = vercelConfig?.experimentalServices;
+      const hasConfiguredServices = configuredServices && Object.keys(configuredServices).length > 0;
+      if (!hasConfiguredServices) {
+        return {
+          services: [],
+          routes: { rewrites: [], defaults: [], crons: [], workers: [] },
+          errors: [
+            {
+              code: "NO_SERVICES_CONFIGURED",
+              message: "No services configured. Add `experimentalServices` to vercel.json."
+            }
+          ],
+          warnings: []
+        };
+      }
+      const result = (0, import_resolve.resolveAllConfiguredServices)(configuredServices);
+      const routes = generateServicesRoutes2(result.services);
+      return {
+        services: result.services,
+        routes,
+        errors: result.errors,
+        warnings: []
+      };
+    }
+    function generateServicesRoutes2(services) {
+      const rewrites = [];
+      const defaults = [];
+      const crons = [];
+      const workers = [];
+      const webServices = services.filter(
+        (s) => s.type === "web" && typeof s.routePrefix === "string"
+      );
+      const sortedWebServices = [...webServices].sort((a, b) => {
+        if (a.routePrefix === "/")
+          return 1;
+        if (b.routePrefix === "/")
+          return -1;
+        return b.routePrefix.length - a.routePrefix.length;
+      });
+      for (const service of sortedWebServices) {
+        const { routePrefix, builder } = service;
+        const builderSrc = builder.src || routePrefix;
+        const functionPath = builderSrc.startsWith("/") ? builderSrc : `/${builderSrc}`;
+        if (routePrefix === "/") {
+          defaults.push({
+            src: "^/(.*)$",
+            dest: functionPath,
+            check: true
+          });
+        } else {
+          const normalizedPrefix = routePrefix.startsWith("/") ? routePrefix.slice(1) : routePrefix;
+          rewrites.push({
+            src: `^/${normalizedPrefix}(?:/.*)?$`,
+            dest: functionPath,
+            check: true
+          });
+        }
+      }
+      return { rewrites, defaults, crons, workers };
+    }
+  }
+});
+
+// ../fs-detectors/dist/detectors/filesystem.js
+var require_filesystem = __commonJS({
+  "../fs-detectors/dist/detectors/filesystem.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 filesystem_exports = {};
+    __export2(filesystem_exports, {
+      DetectorFilesystem: () => DetectorFilesystem2
+    });
+    module2.exports = __toCommonJS2(filesystem_exports);
+    var import_path7 = require("path");
+    var DetectorFilesystem2 = class {
+      constructor() {
+        this.hasPath = async (path6) => {
+          let p = this.pathCache.get(path6);
+          if (!p) {
+            p = this._hasPath(path6);
+            this.pathCache.set(path6, p);
+          }
+          return p;
+        };
+        this.isFile = async (name) => {
+          let p = this.fileCache.get(name);
+          if (!p) {
+            p = this._isFile(name);
+            this.fileCache.set(name, p);
+          }
+          return p;
+        };
+        this.readFile = async (name) => {
+          let p = this.readFileCache.get(name);
+          if (!p) {
+            p = this._readFile(name);
+            this.readFileCache.set(name, p);
+          }
+          return p;
+        };
+        this.readdir = async (dirPath, options) => {
+          let p = this.readdirCache.get(dirPath);
+          if (!p) {
+            p = this._readdir(dirPath);
+            this.readdirCache.set(dirPath, p);
+          }
+          const directoryContent = await p;
+          const directoryFiles = /* @__PURE__ */ new Set();
+          for (const file of directoryContent) {
+            if (file.type === "file") {
+              this.fileCache.set(file.path, Promise.resolve(true));
+              this.pathCache.set(file.path, Promise.resolve(true));
+              directoryFiles.add(file.name);
+            }
+          }
+          if (options?.potentialFiles) {
+            const filesInReaddirDir = options.potentialFiles.filter(
+              (path6) => (0, import_path7.basename)(path6) === path6
+            );
+            const filesThatDoNotExist = filesInReaddirDir.filter(
+              (path6) => !directoryFiles.has(path6)
+            );
+            for (const filePath of filesThatDoNotExist) {
+              const fullFilePath = dirPath === "/" ? filePath : import_path7.posix.join(dirPath, filePath);
+              this.fileCache.set(fullFilePath, Promise.resolve(false));
+              this.pathCache.set(fullFilePath, Promise.resolve(false));
+            }
+          }
+          return p;
+        };
+        this.chdir = (name) => {
+          return this._chdir(name);
+        };
+        this.writeFile = async (name, content) => {
+          this.readFileCache.set(name, Promise.resolve(Buffer.from(content)));
+          this.fileCache.set(name, Promise.resolve(true));
+          this.pathCache.set(name, Promise.resolve(true));
+        };
+        this.pathCache = /* @__PURE__ */ new Map();
+        this.fileCache = /* @__PURE__ */ new Map();
+        this.readFileCache = /* @__PURE__ */ new Map();
+        this.readdirCache = /* @__PURE__ */ new Map();
+      }
+    };
+  }
+});
+
+// ../fs-detectors/dist/detectors/local-file-system-detector.js
+var require_local_file_system_detector = __commonJS({
+  "../fs-detectors/dist/detectors/local-file-system-detector.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
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var local_file_system_detector_exports = {};
+    __export2(local_file_system_detector_exports, {
+      LocalFileSystemDetector: () => LocalFileSystemDetector3
+    });
+    module2.exports = __toCommonJS2(local_file_system_detector_exports);
+    var import_promises = __toESM2(require("fs/promises"));
+    var import_path7 = require("path");
+    var import_filesystem = require_filesystem();
+    var import_error_utils3 = require_dist();
+    var LocalFileSystemDetector3 = class _LocalFileSystemDetector extends import_filesystem.DetectorFilesystem {
+      constructor(rootPath) {
+        super();
+        this.rootPath = rootPath;
+      }
+      async _hasPath(name) {
+        try {
+          await import_promises.default.stat(this.getFilePath(name));
+          return true;
+        } catch (err) {
+          if ((0, import_error_utils3.isErrnoException)(err) && err.code === "ENOENT") {
+            return false;
+          }
+          throw err;
+        }
+      }
+      _readFile(name) {
+        return import_promises.default.readFile(this.getFilePath(name));
+      }
+      async _isFile(name) {
+        const stat = await import_promises.default.stat(this.getFilePath(name));
+        return stat.isFile();
+      }
+      async _readdir(dir) {
+        const dirPath = this.getFilePath(dir);
+        const entries = await import_promises.default.readdir(dirPath, { withFileTypes: true });
+        const result = [];
+        for (const entry of entries) {
+          let type;
+          if (entry.isFile()) {
+            type = "file";
+          } else if (entry.isDirectory()) {
+            type = "dir";
+          } else {
+            continue;
+          }
+          result.push({
+            name: entry.name,
+            path: (0, import_path7.join)(this.getRelativeFilePath(dir), entry.name),
+            type
+          });
+        }
+        return result;
+      }
+      _chdir(name) {
+        return new _LocalFileSystemDetector(this.getFilePath(name));
+      }
+      getRelativeFilePath(name) {
+        return name.startsWith(this.rootPath) ? (0, import_path7.relative)(this.rootPath, name) : name;
+      }
+      getFilePath(name) {
+        return (0, import_path7.join)(this.rootPath, this.getRelativeFilePath(name));
+      }
+    };
+  }
+});
+
+// ../fs-detectors/dist/services/get-services-builders.js
+var require_get_services_builders = __commonJS({
+  "../fs-detectors/dist/services/get-services-builders.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 get_services_builders_exports = {};
+    __export2(get_services_builders_exports, {
+      getServicesBuilders: () => getServicesBuilders2
+    });
+    module2.exports = __toCommonJS2(get_services_builders_exports);
+    var import_detect_services = require_detect_services();
+    var import_local_file_system_detector = require_local_file_system_detector();
+    async function getServicesBuilders2(options) {
+      const { workPath } = options;
+      if (!workPath) {
+        return {
+          builders: null,
+          errors: [
+            {
+              code: "MISSING_WORK_PATH",
+              message: "workPath is required for services detection."
+            }
+          ],
+          warnings: [],
+          defaultRoutes: null,
+          redirectRoutes: null,
+          rewriteRoutes: null,
+          errorRoutes: null
+        };
+      }
+      const fs5 = new import_local_file_system_detector.LocalFileSystemDetector(workPath);
+      const result = await (0, import_detect_services.detectServices)({ fs: fs5 });
+      const warningResponses = result.warnings.map((w) => ({
+        code: w.code,
+        message: w.message
+      }));
+      if (result.errors.length > 0) {
+        return {
+          builders: null,
+          errors: result.errors.map((e) => ({
+            code: e.code,
+            message: e.message
+          })),
+          warnings: warningResponses,
+          defaultRoutes: null,
+          redirectRoutes: null,
+          rewriteRoutes: null,
+          errorRoutes: null
+        };
+      }
+      if (result.services.length === 0) {
+        return {
+          builders: null,
+          errors: [
+            {
+              code: "NO_SERVICES_CONFIGURED",
+              message: "No services configured. Add `experimentalServices` to vercel.json."
+            }
+          ],
+          warnings: warningResponses,
+          defaultRoutes: null,
+          redirectRoutes: null,
+          rewriteRoutes: null,
+          errorRoutes: null
+        };
+      }
+      const builders = result.services.map((service) => service.builder);
+      return {
+        builders: builders.length > 0 ? builders : null,
+        errors: null,
+        warnings: warningResponses,
+        defaultRoutes: result.routes.defaults.length > 0 ? result.routes.defaults : null,
+        redirectRoutes: [],
+        rewriteRoutes: result.routes.rewrites.length > 0 ? result.routes.rewrites : null,
+        errorRoutes: [],
+        services: result.services
+      };
+    }
+  }
+});
+
+// ../fs-detectors/dist/detect-builders.js
+var require_detect_builders = __commonJS({
+  "../fs-detectors/dist/detect-builders.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
+    ));
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var detect_builders_exports = {};
+    __export2(detect_builders_exports, {
+      REGEX_MIDDLEWARE_FILES: () => REGEX_MIDDLEWARE_FILES,
+      REGEX_NON_VERCEL_PLATFORM_FILES: () => REGEX_NON_VERCEL_PLATFORM_FILES2,
+      REGEX_VERCEL_PLATFORM_FILES: () => REGEX_VERCEL_PLATFORM_FILES,
+      detectApiDirectory: () => detectApiDirectory2,
+      detectApiExtensions: () => detectApiExtensions2,
+      detectBuilders: () => detectBuilders2,
+      detectOutputDirectory: () => detectOutputDirectory2,
+      sortFiles: () => sortFiles
+    });
+    module2.exports = __toCommonJS2(detect_builders_exports);
+    var import_minimatch = __toESM2(require_minimatch());
+    var import_semver2 = require_semver3();
+    var import_path7 = require("path");
+    var import_frameworks2 = __toESM2(require_frameworks());
+    var import_is_official_runtime = require_is_official_runtime();
+    var import_build_utils5 = require("@vercel/build-utils");
+    var import_get_services_builders = require_get_services_builders();
+    var REGEX_MIDDLEWARE_FILES = "middleware.[jt]s";
+    var REGEX_VERCEL_PLATFORM_FILES = `api/**,package.json,${REGEX_MIDDLEWARE_FILES}`;
+    var REGEX_NON_VERCEL_PLATFORM_FILES2 = `!{${REGEX_VERCEL_PLATFORM_FILES}}`;
+    var slugToFramework = new Map(
+      import_frameworks2.default.map((f) => [f.slug, f])
+    );
+    function sortFiles(fileA, fileB) {
+      return fileA.localeCompare(fileB);
+    }
+    function detectApiExtensions2(builders) {
+      return new Set(
+        builders.filter(
+          (b) => Boolean(b.config && b.config.zeroConfig && b.src?.startsWith("api/"))
+        ).map((b) => (0, import_path7.extname)(b.src)).filter(Boolean)
+      );
+    }
+    function detectApiDirectory2(builders) {
+      const found = builders.some(
+        (b) => b.config && b.config.zeroConfig && b.src?.startsWith("api/")
+      );
+      return found ? "api" : null;
+    }
+    function getPublicBuilder(builders) {
+      for (const builder of builders) {
+        if (typeof builder.src === "string" && (0, import_is_official_runtime.isOfficialRuntime)("static", builder.use) && /^.*\/\*\*\/\*$/.test(builder.src) && builder.config?.zeroConfig === true) {
+          return builder;
+        }
+      }
+      return null;
+    }
+    function detectOutputDirectory2(builders) {
+      const publicBuilder = getPublicBuilder(builders);
+      return publicBuilder ? publicBuilder.src.replace("/**/*", "") : null;
+    }
+    async function detectBuilders2(files, pkg, options = {}) {
+      const { projectSettings = {} } = options;
+      const { framework } = projectSettings;
+      if (framework === "services") {
+        return (0, import_get_services_builders.getServicesBuilders)({
+          workPath: options.workPath
+        });
+      }
+      const errors = [];
+      const warnings = [];
+      let apiBuilders = [];
       let frontendBuilder = null;
       const functionError = validateFunctions(options);
       if (functionError) {
@@ -19639,8 +20519,7 @@ var require_detect_builders = __commonJS({
           usedFunctions.add(key);
       };
       const absolutePathCache = /* @__PURE__ */ new Map();
-      const { projectSettings = {} } = options;
-      const { buildCommand, outputDirectory, framework } = projectSettings;
+      const { buildCommand, outputDirectory } = projectSettings;
       const frameworkConfig = slugToFramework.get(framework || "");
       const ignoreRuntimes = new Set(frameworkConfig?.ignoreRuntimes);
       const withTag = options.tag ? `@${options.tag}` : "";
@@ -19942,7 +20821,9 @@ var require_detect_builders = __commonJS({
       const f = slugToFramework.get(framework || "");
       if (f && f.useRuntime) {
         const { src, use } = f.useRuntime;
-        return { src, use: `${use}${withTag}`, config };
+        const shouldUseUnifiedBackend = (0, import_build_utils5.isExperimentalBackendsEnabled)() && import_build_utils5.BACKEND_BUILDERS.includes(use);
+        const finalUse = shouldUseUnifiedBackend ? import_build_utils5.UNIFIED_BACKEND_BUILDER : use;
+        return { src, use: `${finalUse}${withTag}`, config };
       }
       const entrypoints = /* @__PURE__ */ new Set([
         "package.json",
@@ -20285,230 +21166,68 @@ var require_detect_builders = __commonJS({
                 src: `^/api/(.+)${extGroup}$`,
                 dest: "/api/$1",
                 check: true
-              });
-            }
-          }
-          rewriteRoutes.push(...dynamicRoutes);
-          const hasApiBuild = apiBuilders.find((builder) => {
-            return builder.src?.startsWith("api/");
-          });
-          if (typeof ignoreRuntimes === "undefined" && hasApiBuild) {
-            rewriteRoutes.push({
-              src: "^/api(/.*)?$",
-              status: 404
-            });
-          }
-        } else {
-          defaultRoutes.push(...apiRoutes);
-          if (apiRoutes.length) {
-            defaultRoutes.push({
-              status: 404,
-              src: "^/api(/.*)?$"
-            });
-          }
-        }
-      }
-      if (outputDirectory && frontendBuilder && !options.featHandleMiss && (0, import_is_official_runtime.isOfficialRuntime)("static", frontendBuilder.use)) {
-        defaultRoutes.push({
-          src: "/(.*)",
-          dest: `/${outputDirectory}/$1`
-        });
-      }
-      if (options.featHandleMiss && !isNextjs && !isGatsby) {
-        errorRoutes.push({
-          status: 404,
-          src: "^(?!/api).*$",
-          dest: options.cleanUrls ? "/404" : "/404.html"
-        });
-      }
-      return {
-        defaultRoutes,
-        redirectRoutes,
-        rewriteRoutes,
-        errorRoutes
-      };
-    }
-    function sortFilesBySegmentCount(fileA, fileB) {
-      const lengthA = fileA.split("/").length;
-      const lengthB = fileB.split("/").length;
-      if (lengthA > lengthB) {
-        return -1;
-      }
-      if (lengthA < lengthB) {
-        return 1;
-      }
-      const countSegments = (prev, segment) => getSegmentName(segment) ? prev + 1 : 0;
-      const segmentLengthA = fileA.split("/").reduce(countSegments, 0);
-      const segmentLengthB = fileB.split("/").reduce(countSegments, 0);
-      if (segmentLengthA > segmentLengthB) {
-        return 1;
-      }
-      if (segmentLengthA < segmentLengthB) {
-        return -1;
-      }
-      return fileA.localeCompare(fileB);
-    }
-  }
-});
-
-// ../fs-detectors/dist/services/resolve.js
-var require_resolve = __commonJS({
-  "../fs-detectors/dist/services/resolve.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 resolve_exports = {};
-    __export2(resolve_exports, {
-      resolveService: () => resolveService,
-      validateServiceConfig: () => validateServiceConfig
-    });
-    module2.exports = __toCommonJS2(resolve_exports);
-    function validateServiceConfig(name, config) {
-      if (config.type === "cron" && !config.schedule) {
-        return {
-          code: "MISSING_CRON_SCHEDULE",
-          message: `Cron service "${name}" is missing required "schedule" field`,
-          serviceName: name
-        };
-      }
-      return null;
-    }
-    function resolveService(name, config, group) {
-      const type = config.type || "web";
-      const workspace = config.workspace || ".";
-      const topic = type === "worker" ? config.topic || "default" : config.topic;
-      const consumer = type === "worker" ? config.consumer || "default" : config.consumer;
-      return {
-        name,
-        type,
-        group,
-        workspace,
-        entrypoint: config.entrypoint,
-        routePrefix: config.routePrefix,
-        framework: config.framework,
-        builder: config.builder,
-        runtime: config.runtime,
-        buildCommand: config.buildCommand,
-        installCommand: config.installCommand,
-        memory: config.memory,
-        maxDuration: config.maxDuration,
-        includeFiles: config.includeFiles,
-        excludeFiles: config.excludeFiles,
-        schedule: config.schedule,
-        topic,
-        consumer
-      };
-    }
-  }
-});
-
-// ../fs-detectors/dist/services/types.js
-var require_types2 = __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, {
-      RUNTIME_BUILDERS: () => RUNTIME_BUILDERS
-    });
-    module2.exports = __toCommonJS2(types_exports);
-    var RUNTIME_BUILDERS = {
-      node: "@vercel/node",
-      python: "@vercel/python",
-      go: "@vercel/go",
-      rust: "@vercel/rust",
-      ruby: "@vercel/ruby"
-    };
-  }
-});
-
-// ../fs-detectors/dist/services/index.js
-var require_services = __commonJS({
-  "../fs-detectors/dist/services/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 services_exports = {};
-    __export2(services_exports, {
-      detectServices: () => detectServices2
-    });
-    module2.exports = __toCommonJS2(services_exports);
-    var import_resolve = require_resolve();
-    __reExport(services_exports, require_types2(), module2.exports);
-    __reExport(services_exports, require_resolve(), module2.exports);
-    async function detectServices2(options) {
-      const { fs: fs5, workPath = "" } = options;
-      const services = [];
-      const errors = [];
-      const configPath = workPath ? `${workPath}/vercel.json` : "vercel.json";
-      let experimentalServices;
-      try {
-        const configBuffer = await fs5.readFile(configPath);
-        const config = JSON.parse(configBuffer.toString("utf-8"));
-        experimentalServices = config.experimentalServices;
-      } catch {
-        return { services, errors };
-      }
-      if (experimentalServices && typeof experimentalServices === "object") {
-        for (const name of Object.keys(experimentalServices)) {
-          const serviceConfig = experimentalServices[name];
-          const validationError = (0, import_resolve.validateServiceConfig)(name, serviceConfig);
-          if (validationError) {
-            errors.push(validationError);
-            continue;
+              });
+            }
+          }
+          rewriteRoutes.push(...dynamicRoutes);
+          const hasApiBuild = apiBuilders.find((builder) => {
+            return builder.src?.startsWith("api/");
+          });
+          if (typeof ignoreRuntimes === "undefined" && hasApiBuild) {
+            rewriteRoutes.push({
+              src: "^/api(/.*)?$",
+              status: 404
+            });
+          }
+        } else {
+          defaultRoutes.push(...apiRoutes);
+          if (apiRoutes.length) {
+            defaultRoutes.push({
+              status: 404,
+              src: "^/api(/.*)?$"
+            });
           }
-          const resolved = (0, import_resolve.resolveService)(name, serviceConfig);
-          services.push(resolved);
         }
       }
-      return { services, errors };
+      if (outputDirectory && frontendBuilder && !options.featHandleMiss && (0, import_is_official_runtime.isOfficialRuntime)("static", frontendBuilder.use)) {
+        defaultRoutes.push({
+          src: "/(.*)",
+          dest: `/${outputDirectory}/$1`
+        });
+      }
+      if (options.featHandleMiss && !isNextjs && !isGatsby) {
+        errorRoutes.push({
+          status: 404,
+          src: "^(?!/api).*$",
+          dest: options.cleanUrls ? "/404" : "/404.html"
+        });
+      }
+      return {
+        defaultRoutes,
+        redirectRoutes,
+        rewriteRoutes,
+        errorRoutes
+      };
+    }
+    function sortFilesBySegmentCount(fileA, fileB) {
+      const lengthA = fileA.split("/").length;
+      const lengthB = fileB.split("/").length;
+      if (lengthA > lengthB) {
+        return -1;
+      }
+      if (lengthA < lengthB) {
+        return 1;
+      }
+      const countSegments = (prev, segment) => getSegmentName(segment) ? prev + 1 : 0;
+      const segmentLengthA = fileA.split("/").reduce(countSegments, 0);
+      const segmentLengthB = fileB.split("/").reduce(countSegments, 0);
+      if (segmentLengthA > segmentLengthB) {
+        return 1;
+      }
+      if (segmentLengthA < segmentLengthB) {
+        return -1;
+      }
+      return fileA.localeCompare(fileB);
     }
   }
 });
@@ -21039,203 +21758,6 @@ var require_get_project_paths = __commonJS({
   }
 });
 
-// ../fs-detectors/dist/detectors/filesystem.js
-var require_filesystem = __commonJS({
-  "../fs-detectors/dist/detectors/filesystem.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 filesystem_exports = {};
-    __export2(filesystem_exports, {
-      DetectorFilesystem: () => DetectorFilesystem2
-    });
-    module2.exports = __toCommonJS2(filesystem_exports);
-    var import_path7 = require("path");
-    var DetectorFilesystem2 = class {
-      constructor() {
-        this.hasPath = async (path6) => {
-          let p = this.pathCache.get(path6);
-          if (!p) {
-            p = this._hasPath(path6);
-            this.pathCache.set(path6, p);
-          }
-          return p;
-        };
-        this.isFile = async (name) => {
-          let p = this.fileCache.get(name);
-          if (!p) {
-            p = this._isFile(name);
-            this.fileCache.set(name, p);
-          }
-          return p;
-        };
-        this.readFile = async (name) => {
-          let p = this.readFileCache.get(name);
-          if (!p) {
-            p = this._readFile(name);
-            this.readFileCache.set(name, p);
-          }
-          return p;
-        };
-        this.readdir = async (dirPath, options) => {
-          let p = this.readdirCache.get(dirPath);
-          if (!p) {
-            p = this._readdir(dirPath);
-            this.readdirCache.set(dirPath, p);
-          }
-          const directoryContent = await p;
-          const directoryFiles = /* @__PURE__ */ new Set();
-          for (const file of directoryContent) {
-            if (file.type === "file") {
-              this.fileCache.set(file.path, Promise.resolve(true));
-              this.pathCache.set(file.path, Promise.resolve(true));
-              directoryFiles.add(file.name);
-            }
-          }
-          if (options?.potentialFiles) {
-            const filesInReaddirDir = options.potentialFiles.filter(
-              (path6) => (0, import_path7.basename)(path6) === path6
-            );
-            const filesThatDoNotExist = filesInReaddirDir.filter(
-              (path6) => !directoryFiles.has(path6)
-            );
-            for (const filePath of filesThatDoNotExist) {
-              const fullFilePath = dirPath === "/" ? filePath : import_path7.posix.join(dirPath, filePath);
-              this.fileCache.set(fullFilePath, Promise.resolve(false));
-              this.pathCache.set(fullFilePath, Promise.resolve(false));
-            }
-          }
-          return p;
-        };
-        this.chdir = (name) => {
-          return this._chdir(name);
-        };
-        this.writeFile = async (name, content) => {
-          this.readFileCache.set(name, Promise.resolve(Buffer.from(content)));
-          this.fileCache.set(name, Promise.resolve(true));
-          this.pathCache.set(name, Promise.resolve(true));
-        };
-        this.pathCache = /* @__PURE__ */ new Map();
-        this.fileCache = /* @__PURE__ */ new Map();
-        this.readFileCache = /* @__PURE__ */ new Map();
-        this.readdirCache = /* @__PURE__ */ new Map();
-      }
-    };
-  }
-});
-
-// ../fs-detectors/dist/detectors/local-file-system-detector.js
-var require_local_file_system_detector = __commonJS({
-  "../fs-detectors/dist/detectors/local-file-system-detector.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
-    ));
-    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
-    var local_file_system_detector_exports = {};
-    __export2(local_file_system_detector_exports, {
-      LocalFileSystemDetector: () => LocalFileSystemDetector3
-    });
-    module2.exports = __toCommonJS2(local_file_system_detector_exports);
-    var import_promises = __toESM2(require("fs/promises"));
-    var import_path7 = require("path");
-    var import_filesystem = require_filesystem();
-    var import_error_utils3 = require_dist();
-    var LocalFileSystemDetector3 = class _LocalFileSystemDetector extends import_filesystem.DetectorFilesystem {
-      constructor(rootPath) {
-        super();
-        this.rootPath = rootPath;
-      }
-      async _hasPath(name) {
-        try {
-          await import_promises.default.stat(this.getFilePath(name));
-          return true;
-        } catch (err) {
-          if ((0, import_error_utils3.isErrnoException)(err) && err.code === "ENOENT") {
-            return false;
-          }
-          throw err;
-        }
-      }
-      _readFile(name) {
-        return import_promises.default.readFile(this.getFilePath(name));
-      }
-      async _isFile(name) {
-        const stat = await import_promises.default.stat(this.getFilePath(name));
-        return stat.isFile();
-      }
-      async _readdir(dir) {
-        const dirPath = this.getFilePath(dir);
-        const entries = await import_promises.default.readdir(dirPath, { withFileTypes: true });
-        const result = [];
-        for (const entry of entries) {
-          let type;
-          if (entry.isFile()) {
-            type = "file";
-          } else if (entry.isDirectory()) {
-            type = "dir";
-          } else {
-            continue;
-          }
-          result.push({
-            name: entry.name,
-            path: (0, import_path7.join)(this.getRelativeFilePath(dir), entry.name),
-            type
-          });
-        }
-        return result;
-      }
-      _chdir(name) {
-        return new _LocalFileSystemDetector(this.getFilePath(name));
-      }
-      getRelativeFilePath(name) {
-        return name.startsWith(this.rootPath) ? (0, import_path7.relative)(this.rootPath, name) : name;
-      }
-      getFilePath(name) {
-        return (0, import_path7.join)(this.rootPath, this.getRelativeFilePath(name));
-      }
-    };
-  }
-});
-
 // ../fs-detectors/dist/workspaces/workspace-managers.js
 var require_workspace_managers = __commonJS({
   "../fs-detectors/dist/workspaces/workspace-managers.js"(exports2, module2) {
@@ -28402,8 +28924,10 @@ var require_dist4 = __commonJS({
       detectFrameworks: () => import_detect_framework.detectFrameworks,
       detectInstrumentation: () => import_detect_instrumentation.detectInstrumentation,
       detectOutputDirectory: () => import_detect_builders.detectOutputDirectory,
-      detectServices: () => import_services.detectServices,
+      detectServices: () => import_detect_services.detectServices,
+      generateServicesRoutes: () => import_detect_services.generateServicesRoutes,
       getProjectPaths: () => import_get_project_paths.getProjectPaths,
+      getServicesBuilders: () => import_get_services_builders.getServicesBuilders,
       getWorkspacePackagePaths: () => import_get_workspace_package_paths.getWorkspacePackagePaths,
       getWorkspaces: () => import_get_workspaces.getWorkspaces,
       isOfficialRuntime: () => import_is_official_runtime.isOfficialRuntime,
@@ -28414,7 +28938,8 @@ var require_dist4 = __commonJS({
     });
     module2.exports = __toCommonJS2(src_exports2);
     var import_detect_builders = require_detect_builders();
-    var import_services = require_services();
+    var import_detect_services = require_detect_services();
+    var import_get_services_builders = require_get_services_builders();
     var import_detect_file_system_api = require_detect_file_system_api();
     var import_detect_framework = require_detect_framework();
     var import_get_project_paths = require_get_project_paths();