@vercel/fs-detectors 6.15.10 → 7.0.0

package/dist/services/detect-render.js

@@ -1,230 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // 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 ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var detect_render_exports = {};
-__export(detect_render_exports, {
-  detectRenderServices: () => detectRenderServices
-});
-module.exports = __toCommonJS(detect_render_exports);
-var import_js_yaml = __toESM(require("js-yaml"));
-var import_detect_framework = require("../detect-framework");
-var import_types = require("./types");
-var import_utils = require("./utils");
-const RENDER_YAML = "render.yaml";
-const SERVICE_TYPE_MAP = {
-  web: "web",
-  static: "web"
-};
-async function detectRenderServices(options) {
-  const { fs, detectEntrypoint } = options;
-  const raw = await readRenderYaml(fs);
-  if (raw.warning) {
-    return { services: null, errors: [], warnings: [raw.warning] };
-  } else if (!raw.content) {
-    return { services: null, errors: [], warnings: [] };
-  }
-  const parsed = tryParseRenderConfig(raw.content);
-  if (parsed.warning) {
-    return { services: null, errors: [], warnings: [parsed.warning] };
-  } else if (!parsed.config) {
-    return { services: null, errors: [], warnings: [] };
-  }
-  const renderServices = parsed.config.services;
-  if (!Array.isArray(renderServices) || renderServices.length === 0) {
-    return { services: null, errors: [], warnings: [] };
-  }
-  const services = {};
-  const serviceNames = /* @__PURE__ */ new Set();
-  const errors = [];
-  const warnings = [];
-  for (const rs of renderServices) {
-    const serviceType = rs.type;
-    if (serviceType === "cron") {
-      const name = rs.name ?? "unnamed";
-      const schedule = rs.schedule;
-      const runtime = rs.runtime && rs.runtime in import_types.RUNTIME_BUILDERS ? rs.runtime : void 0;
-      const hint = {
-        type: "cron",
-        ...schedule ? { schedule } : {},
-        entrypoint: "<path-to-handler>",
-        ...runtime ? { runtime } : {}
-      };
-      warnings.push({
-        code: "RENDER_CRON_HINT",
-        message: `Found Render cron service "${name}"` + (schedule ? ` (schedule: "${schedule}")` : "") + `. Vercel crons work with a file entrypoint. You can add the following to define this cron service:
-"${name}": ${JSON.stringify(hint, null, 2)}`
-      });
-      continue;
-    }
-    if (serviceType === "worker") {
-      const name = rs.name ?? "unnamed";
-      const runtime = rs.runtime ?? "unknown";
-      if (runtime === "python") {
-        const hint = {
-          type: "worker",
-          entrypoint: "<path-to-celery-app>",
-          runtime: "python"
-        };
-        warnings.push({
-          code: "RENDER_WORKER_HINT",
-          message: `Found Render worker service "${name}". Python workers using Celery are supported. You can add the following to define this worker:
-"${name}": ${JSON.stringify(hint, null, 2)}`
-        });
-      } else {
-        warnings.push({
-          code: "RENDER_WORKER_HINT",
-          message: `Found Render worker service "${name}" with runtime "${runtime}". Only Python workers are currently supported.`
-        });
-      }
-      continue;
-    }
-    if (serviceType === "pserv") {
-      const name = rs.name ?? "unnamed";
-      const hint = {
-        entrypoint: rs.rootDir ?? "<path-to-entrypoint>",
-        mountPath: `/api/${name}`
-      };
-      warnings.push({
-        code: "RENDER_PSERV_HINT",
-        message: `Found Render private service "${name}". Private services are not yet supported. If you'd like to deploy it as a regular web service, you can add the following:
-"${name}": ${JSON.stringify(hint, null, 2)}`
-      });
-      continue;
-    }
-    if (!serviceType || !(serviceType in SERVICE_TYPE_MAP)) {
-      continue;
-    }
-    const serviceName = rs.name;
-    if (!serviceName) {
-      warnings.push({
-        code: "RENDER_CONFIG_ERROR",
-        message: "Skipped a Render service with no name. Each service in render.yaml must have a name."
-      });
-      continue;
-    }
-    if (serviceNames.has(serviceName)) {
-      errors.push({
-        code: "DUPLICATE_SERVICE",
-        message: `Duplicate service name "${serviceName}" in render.yaml.`,
-        serviceName
-      });
-      continue;
-    }
-    serviceNames.add(serviceName);
-    const rootDir = rs.rootDir || ".";
-    const serviceFs = rootDir === "." ? fs : fs.chdir(rootDir);
-    const frameworks = await (0, import_detect_framework.detectFrameworks)({
-      fs: serviceFs,
-      frameworkList: import_utils.DETECTION_FRAMEWORKS,
-      useExperimentalFrameworks: true
-    });
-    if (frameworks.length === 0) {
-      warnings.push({
-        code: "SERVICE_SKIPPED",
-        message: `Skipped Render service "${serviceName}": no framework detected. Configure it manually in services.`
-      });
-      continue;
-    }
-    if (frameworks.length > 1) {
-      const names = frameworks.map((f) => f.name).join(", ");
-      errors.push({
-        code: "MULTIPLE_FRAMEWORKS_SERVICE",
-        message: `Multiple frameworks detected for Render service "${serviceName}": ${names}. Use explicit services config.`,
-        serviceName
-      });
-      continue;
-    }
-    const framework = frameworks[0];
-    const vercelType = SERVICE_TYPE_MAP[serviceType];
-    const serviceConfig = {
-      root: rootDir,
-      type: vercelType,
-      framework: framework.slug ?? void 0
-    };
-    if (rootDir !== "." && detectEntrypoint && !(0, import_utils.isFrontendFramework)(serviceConfig.framework)) {
-      const detected = await detectEntrypoint({
-        workPath: rootDir,
-        framework: serviceConfig.framework
-      });
-      if (detected) {
-        serviceConfig.entrypoint = detected.entrypoint;
-      }
-    }
-    const buildCommand = (0, import_utils.combineBuildCommand)(
-      rs.buildCommand,
-      rs.preDeployCommand
-    );
-    if (buildCommand) {
-      serviceConfig.buildCommand = buildCommand;
-    }
-    services[serviceName] = serviceConfig;
-  }
-  if (errors.length > 0) {
-    return { services: null, errors, warnings };
-  }
-  if (Object.keys(services).length === 0) {
-    return { services: null, errors: [], warnings };
-  }
-  warnings.push(...(0, import_utils.assignMountPaths)(services));
-  return { services, errors: [], warnings };
-}
-async function readRenderYaml(fs) {
-  try {
-    const exists = await fs.isFile(RENDER_YAML);
-    if (!exists)
-      return { content: null };
-    const buf = await fs.readFile(RENDER_YAML);
-    return { content: buf.toString("utf-8") };
-  } catch (err) {
-    return {
-      content: null,
-      warning: {
-        code: "RENDER_CONFIG_ERROR",
-        message: `Failed to read ${RENDER_YAML}: ${err instanceof Error ? err.message : String(err)}`
-      }
-    };
-  }
-}
-function tryParseRenderConfig(content) {
-  try {
-    const config = import_js_yaml.default.load(content);
-    return { config };
-  } catch (err) {
-    return {
-      config: null,
-      warning: {
-        code: "RENDER_PARSE_ERROR",
-        message: `Failed to parse ${RENDER_YAML}: ${err instanceof Error ? err.message : String(err)}`
-      }
-    };
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  detectRenderServices
-});

package/dist/services/detect-services.d.ts

@@ -1,48 +0,0 @@
-import type { Rewrite } from '@vercel/routing-utils';
-import type { DetectServicesOptions, DetectServicesResult, InferredServicesConfig, Service, ServicesRoutes } from './types';
-/**
- * Detect and resolve services within a project.
- *
- * Reads vercel.json and resolves configured services into Service objects.
- * Returns an error if no services are configured.
- */
-export declare function detectServices(options: DetectServicesOptions): Promise<DetectServicesResult>;
-/**
- * Generate top-level service-targeted rewrites from inferred mount paths.
- *
- * Produces `Rewrite` objects (same format as vercel.json `rewrites`) that
- * delegate public traffic into services based on their `mountPath`.
- *
- * Rewrites are ordered by mount path length (longest first) so more
- * specific paths match before broader ones. The root service (`/`) is
- * always last as a catch-all.
- */
-export declare function generateServiceRewrites(services: InferredServicesConfig): Rewrite[];
-/**
- * Generate routing rules for services.
- *
- * Routes are ordered by prefix length (longest first) to ensure more specific
- * routes match before broader ones. For example, `/api/users` must be checked
- * before `/api`, which must be checked before the catch-all `/`.
- *
- * Services routing only generates *synthetic* routes for builders that do not
- * provide their own route tables:
- *
- * - **Static/SPA services** (`@vercel/static-build`, `@vercel/static`):
- *   SPA fallback routes to index.html under the service prefix.
- *
- * - **Runtime services** (`@vercel/python`, `@vercel/go`, `@vercel/ruby`, etc.):
- *   Prefix rewrites to an internal runtime destination (`/_svc/{name}/index`)
- *   with `check: true`.
- *
- * Builders that provide their own routing (`@vercel/next`, `@vercel/backends`,
- * Build Output API builders, etc.) are not given synthetic routes here.
- *
- * - Worker and queue-triggered job services:
- *   Use private path routing. The generated function is not publicly accessible.
- *
- * - Schedule-triggered job services:
- *   Internal cron callback routes under `/_svc/{serviceName}/crons/{entry}/{handler}`
- *   that rewrite to `/_svc/{serviceName}/index`.
- */
-export declare function generateServicesRoutes(allServices: Service[]): ServicesRoutes;

package/dist/services/detect-services.js

@@ -1,423 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var detect_services_exports = {};
-__export(detect_services_exports, {
-  detectServices: () => detectServices,
-  generateServiceRewrites: () => generateServiceRewrites,
-  generateServicesRoutes: () => generateServicesRoutes
-});
-module.exports = __toCommonJS(detect_services_exports);
-var import_build_utils = require("@vercel/build-utils");
-var import_routing_utils = require("@vercel/routing-utils");
-var import_utils = require("./utils");
-var import_resolve = require("./resolve");
-var import_resolve_v2 = require("./resolve-v2");
-var import_auto_detect = require("./auto-detect");
-var import_detect_railway = require("./detect-railway");
-var import_detect_render = require("./detect-render");
-var import_detect_procfile = require("./detect-procfile");
-const PREVIEW_DOMAIN_MISSING = [
-  { type: "host", value: { suf: ".vercel.app" } },
-  { type: "host", value: { suf: ".vercel.dev" } }
-];
-function emptyRoutes() {
-  return {
-    hostRewrites: [],
-    rewrites: [],
-    defaults: [],
-    fallbacks: [],
-    crons: [],
-    workers: []
-  };
-}
-function withResolvedResult(resolved, inferred = null) {
-  return {
-    services: resolved.services,
-    source: resolved.source,
-    useImplicitEnvInjection: resolved.useImplicitEnvInjection,
-    routes: resolved.routes,
-    rewrites: resolved.rewrites,
-    errors: resolved.errors,
-    warnings: resolved.warnings,
-    resolved,
-    inferred
-  };
-}
-function toInferredLayoutConfig(services) {
-  const inferredConfig = {};
-  for (const [name, service] of Object.entries(services)) {
-    const serviceConfig = {
-      root: service.root
-    };
-    if (service.type) {
-      serviceConfig.type = service.type;
-    }
-    if (typeof service.entrypoint === "string") {
-      serviceConfig.entrypoint = service.entrypoint;
-    }
-    if (typeof service.mountPath === "string") {
-      serviceConfig.mountPath = service.mountPath;
-    }
-    if ((0, import_utils.isFrontendFramework)(service.framework)) {
-      serviceConfig.framework = service.framework;
-    }
-    if (typeof service.buildCommand === "string") {
-      serviceConfig.buildCommand = service.buildCommand;
-    }
-    if (typeof service.runtime === "string") {
-      serviceConfig.runtime = service.runtime;
-    }
-    inferredConfig[name] = serviceConfig;
-  }
-  return inferredConfig;
-}
-async function detectServices(options) {
-  const {
-    fs,
-    workPath,
-    detectEntrypoint,
-    configuredServices: providedConfiguredServices,
-    configuredServicesType: providedConfiguredServicesType
-  } = options;
-  const scopedFs = workPath ? fs.chdir(workPath) : fs;
-  const { config: vercelConfig, error: configError } = await (0, import_utils.readVercelConfig)(scopedFs);
-  if (configError) {
-    return withResolvedResult({
-      services: [],
-      source: "configured",
-      useImplicitEnvInjection: true,
-      routes: emptyRoutes(),
-      rewrites: [],
-      errors: [configError],
-      warnings: []
-    });
-  }
-  if (vercelConfig?.services != null && vercelConfig.experimentalServicesV2 != null) {
-    return withResolvedResult({
-      services: [],
-      source: "configured",
-      useImplicitEnvInjection: false,
-      routes: emptyRoutes(),
-      rewrites: [],
-      errors: [
-        {
-          code: "SERVICES_AND_EXPERIMENTAL_SERVICES_V2",
-          message: "The `services` property cannot be used in conjunction with its deprecated alias `experimentalServicesV2`. Please use only `services`."
-        }
-      ],
-      warnings: []
-    });
-  }
-  const hasProvidedConfiguredServices = providedConfiguredServices && Object.keys(providedConfiguredServices).length > 0;
-  const experimentalServicesV2 = hasProvidedConfiguredServices && (providedConfiguredServicesType === "services" || providedConfiguredServicesType === "experimentalServicesV2") ? providedConfiguredServices : hasProvidedConfiguredServices ? void 0 : vercelConfig?.services ?? vercelConfig?.experimentalServicesV2;
-  if (experimentalServicesV2 && Object.keys(experimentalServicesV2).length > 0) {
-    const result = await (0, import_resolve_v2.resolveAllConfiguredServicesV2)(
-      experimentalServicesV2,
-      scopedFs
-    );
-    return withResolvedResult({
-      services: result.services,
-      source: "configured",
-      // V2 uses explicit `bindings`, so no implicit `{NAME}_URL` injection.
-      useImplicitEnvInjection: false,
-      // V2 routes are explicitly carried per-service to output them separately.
-      routes: emptyRoutes(),
-      rewrites: [],
-      errors: result.errors,
-      warnings: []
-    });
-  }
-  const experimentalServicesV1 = hasProvidedConfiguredServices ? providedConfiguredServices : vercelConfig?.experimentalServices;
-  const hasExperimentalServicesV1 = experimentalServicesV1 && Object.keys(experimentalServicesV1).length > 0;
-  if (hasExperimentalServicesV1) {
-    const result = await (0, import_resolve.resolveAllConfiguredServices)(
-      experimentalServicesV1,
-      scopedFs,
-      "configured"
-    );
-    const routes = generateServicesRoutes(result.services);
-    return withResolvedResult({
-      services: result.services,
-      source: "configured",
-      // experimentalServices uses the legacy `{NAME}_URL` injection.
-      useImplicitEnvInjection: true,
-      routes,
-      rewrites: [],
-      errors: result.errors,
-      warnings: []
-    });
-  }
-  const detectors = [
-    { detect: import_detect_railway.detectRailwayServices, source: "railway" },
-    { detect: import_detect_render.detectRenderServices, source: "render" },
-    { detect: import_detect_procfile.detectProcfileServices, source: "procfile" },
-    { detect: import_auto_detect.autoDetectServices, source: "layout" }
-  ];
-  for (const { detect, source } of detectors) {
-    const detectResult = await detect({ fs: scopedFs, detectEntrypoint });
-    const match = await tryResolveInferred(detectResult, source, scopedFs);
-    if (match)
-      return match;
-  }
-  return withResolvedResult({
-    services: [],
-    source: "auto-detected",
-    useImplicitEnvInjection: true,
-    routes: emptyRoutes(),
-    rewrites: [],
-    errors: [
-      {
-        code: "NO_SERVICES_CONFIGURED",
-        message: "No services configured. Add `services` to vercel.json."
-      }
-    ],
-    warnings: []
-  });
-}
-async function tryResolveInferred(detectResult, source, scopedFs) {
-  if (detectResult.errors.length > 0) {
-    return withResolvedResult({
-      services: [],
-      source: "auto-detected",
-      useImplicitEnvInjection: source !== "layout",
-      routes: emptyRoutes(),
-      rewrites: [],
-      errors: detectResult.errors,
-      warnings: detectResult.warnings
-    });
-  }
-  if (!detectResult.services) {
-    return null;
-  }
-  if (source === "layout") {
-    const v2Services = {};
-    for (const [name, svc] of Object.entries(detectResult.services)) {
-      v2Services[name] = {
-        root: svc.root,
-        ...svc.framework ? { framework: svc.framework } : {},
-        ...svc.entrypoint ? { entrypoint: svc.entrypoint } : {}
-      };
-    }
-    const result2 = await (0, import_resolve_v2.resolveAllConfiguredServicesV2)(v2Services, scopedFs);
-    const rootServices = Object.values(detectResult.services).filter(
-      (svc) => svc.mountPath === "/" && typeof svc.framework === "string"
-    );
-    const shouldInfer2 = result2.errors.length === 0 && rootServices.length === 1 && result2.services.length > 1;
-    const inferred2 = shouldInfer2 ? {
-      source,
-      config: toInferredLayoutConfig(detectResult.services),
-      services: result2.services,
-      warnings: detectResult.warnings
-    } : null;
-    return withResolvedResult(
-      {
-        services: shouldInfer2 ? result2.services : [],
-        source: "auto-detected",
-        useImplicitEnvInjection: false,
-        routes: emptyRoutes(),
-        rewrites: shouldInfer2 ? generateServiceRewrites(detectResult.services) : [],
-        experimentalServicesV2: shouldInfer2 ? v2Services : void 0,
-        errors: result2.errors,
-        warnings: detectResult.warnings
-      },
-      inferred2
-    );
-  }
-  const v1Services = {};
-  for (const [name, svc] of Object.entries(detectResult.services)) {
-    v1Services[name] = {
-      root: svc.root === "." ? void 0 : svc.root,
-      ...svc.framework ? { framework: svc.framework } : {},
-      ...svc.entrypoint ? { entrypoint: svc.entrypoint } : {},
-      ...svc.type ? { type: svc.type } : {},
-      ...svc.buildCommand ? { buildCommand: svc.buildCommand } : {},
-      ...svc.preDeployCommand ? { preDeployCommand: svc.preDeployCommand } : {},
-      ...svc.mountPath ? { routePrefix: svc.mountPath } : {}
-    };
-  }
-  const result = await (0, import_resolve.resolveAllConfiguredServices)(
-    v1Services,
-    scopedFs,
-    "generated"
-  );
-  const shouldInfer = result.errors.length === 0 && result.services.length > 0;
-  const inferred = shouldInfer ? {
-    source,
-    config: toInferredLayoutConfig(detectResult.services),
-    services: result.services,
-    warnings: detectResult.warnings
-  } : null;
-  return withResolvedResult(
-    {
-      services: [],
-      source: "auto-detected",
-      useImplicitEnvInjection: true,
-      routes: emptyRoutes(),
-      rewrites: [],
-      errors: result.errors,
-      warnings: detectResult.warnings
-    },
-    inferred
-  );
-}
-function generateServiceRewrites(services) {
-  const entries = Object.entries(services).filter(
-    ([, svc]) => typeof svc.mountPath === "string" && (!svc.type || svc.type === "web")
-  ).sort(([, a], [, b]) => b.mountPath.length - a.mountPath.length);
-  return entries.map(([name, svc]) => {
-    const mountPath = svc.mountPath;
-    if (mountPath === "/") {
-      return {
-        source: "/(.*)",
-        destination: { type: "service", service: name }
-      };
-    }
-    const prefix = mountPath.startsWith("/") ? mountPath.slice(1) : mountPath;
-    return {
-      source: `/${prefix}(/.*)?`,
-      destination: { type: "service", service: name }
-    };
-  });
-}
-function generateServicesRoutes(allServices) {
-  const services = allServices.filter(import_build_utils.isExperimentalService);
-  const hostRewrites = [];
-  const rewrites = [];
-  const defaults = [];
-  const fallbacks = [];
-  const crons = [];
-  const workers = [];
-  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);
-  const explicitHostPrefixGuard = getExplicitHostPrefixNegativeLookahead(allWebPrefixes);
-  for (const service of sortedWebServices) {
-    const { routePrefix } = service;
-    const normalizedPrefix = routePrefix.slice(1);
-    const ownershipGuard = (0, import_routing_utils.getOwnershipGuard)(routePrefix, allWebPrefixes);
-    const hostCondition = getHostCondition(service);
-    if (hostCondition && routePrefix !== "/") {
-      const normalizedRoutePrefix = (0, import_routing_utils.normalizeRoutePrefix)(routePrefix);
-      hostRewrites.push({
-        src: "^/$",
-        dest: normalizedRoutePrefix,
-        has: hostCondition,
-        missing: PREVIEW_DOMAIN_MISSING,
-        check: true
-      });
-      hostRewrites.push({
-        // Preserve explicit service prefixes so canonical paths like /_/api
-        // keep routing to their target service even on another service's host.
-        src: `^/${explicitHostPrefixGuard}(.*)$`,
-        dest: `${normalizedRoutePrefix}/$1`,
-        has: hostCondition,
-        missing: PREVIEW_DOMAIN_MISSING,
-        check: true
-      });
-    }
-    if ((0, import_utils.isRouteOwningBuilder)(service)) {
-      continue;
-    }
-    if ((0, import_utils.isStaticBuild)(service)) {
-      if (routePrefix === "/") {
-        fallbacks.push({
-          src: (0, import_routing_utils.scopeRouteSourceToOwnership)("/(.*)", ownershipGuard),
-          dest: "/index.html"
-        });
-      } else {
-        fallbacks.push({
-          src: (0, import_routing_utils.scopeRouteSourceToOwnership)(
-            `^/${normalizedPrefix}(?:/.*)?$`,
-            ownershipGuard
-          ),
-          dest: `/${normalizedPrefix}/index.html`
-        });
-      }
-    } else if (service.runtime) {
-      const functionPath = (0, import_utils.getInternalServiceFunctionPath)(service.name);
-      const check = service.runtime === "container" ? void 0 : true;
-      if (routePrefix === "/") {
-        defaults.push({
-          src: (0, import_routing_utils.scopeRouteSourceToOwnership)("^/(.*)$", ownershipGuard),
-          dest: functionPath,
-          ...check ? { check } : {}
-        });
-      } else {
-        rewrites.push({
-          src: (0, import_routing_utils.scopeRouteSourceToOwnership)(
-            `^/${normalizedPrefix}(?:/.*)?$`,
-            ownershipGuard
-          ),
-          dest: functionPath,
-          ...check ? { check } : {}
-        });
-      }
-    }
-  }
-  const cronServices = services.filter(import_build_utils.isScheduleTriggeredService);
-  for (const service of cronServices) {
-    const cronPrefix = (0, import_utils.getInternalServiceCronPathPrefix)(service.name);
-    const functionPath = (0, import_utils.getInternalServiceFunctionPath)(service.name);
-    crons.push({
-      src: `^${escapeRegex(cronPrefix)}/.*$`,
-      dest: functionPath,
-      check: true
-    });
-  }
-  return { hostRewrites, rewrites, defaults, fallbacks, crons, workers };
-}
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-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);
-}
-function getExplicitHostPrefixNegativeLookahead(routePrefixes) {
-  const explicitPrefixes = routePrefixes.map(import_routing_utils.normalizeRoutePrefix).filter((prefix) => prefix !== "/").sort((a, b) => b.length - a.length).map((prefix) => escapeRegex(prefix.slice(1)));
-  if (explicitPrefixes.length === 0) {
-    return "";
-  }
-  if (explicitPrefixes.length === 1) {
-    return `(?!${explicitPrefixes[0]}(?:/|$))`;
-  }
-  return `(?!(?:${explicitPrefixes.join("|")})(?:/|$))`;
-}
-function getHostCondition(service) {
-  if (service.type !== "web") {
-    return void 0;
-  }
-  if (typeof service.subdomain === "string" && service.subdomain.length > 0) {
-    return [{ type: "host", value: { pre: `${service.subdomain}.` } }];
-  }
-  return void 0;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  detectServices,
-  generateServiceRewrites,
-  generateServicesRoutes
-});