@vercel/fs-detectors 6.15.10 → 7.0.1

package/dist/services/types.d.ts

@@ -1,134 +0,0 @@
-import type { Rewrite, Route } from '@vercel/routing-utils';
-import type { DetectEntrypointFn, EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceV2Config, ExperimentalServiceGroups, ExperimentalServices, ExperimentalServicesV2, ExperimentalServiceV2Binding, ServiceBinding, ServiceConfig, Services, ExperimentalService, ExperimentalServiceV2, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder } from '@vercel/build-utils';
-import type { DetectorFilesystem } from '../detectors/filesystem';
-export type { DetectEntrypointFn, EnvVar, EnvVars, ExperimentalServiceConfig, ExperimentalServiceGroups, ExperimentalServices, ExperimentalServiceV2Config, ExperimentalServicesV2, ExperimentalServiceV2Binding, ServiceBinding, ServiceConfig, Services, ExperimentalService, ExperimentalServiceV2, ServiceRuntime, ServiceType, ServiceRefEnvVar, Service, Builder, };
-/**
- * @deprecated Use `Service` instead
- */
-export type ResolvedService = Service;
-export interface DetectServicesOptions {
-    fs: DetectorFilesystem;
-    configuredServices?: ConfiguredServices;
-    configuredServicesType?: ConfiguredServicesType;
-    /**
-     * Working directory path (relative to fs root).
-     * If provided, vercel.json is read from this path.
-     */
-    workPath?: string;
-    /**
-     * Optional callback that, given a candidate service directory and its
-     * detected framework, returns a normalized entrypoint (file path or
-     * `module:attr` reference). Used to suggested service configs.
-     */
-    detectEntrypoint?: DetectEntrypointFn;
-}
-export interface ServicesRoutes {
-    /** Host-based rewrite routes for subdomain-mounted web services */
-    hostRewrites: Route[];
-    /** Rewrite routes for non-root web services (prefix-based) */
-    rewrites: Route[];
-    /** Default routes (catch-all for root web service) */
-    defaults: Route[];
-    /** SPA fallback routes for static web services */
-    fallbacks: Route[];
-    /**
-     * Internal routes for schedule-triggered job services.
-     * These route `/_svc/{serviceName}/crons/{entry}/{handler}` to the scheduled job function.
-     */
-    crons: Route[];
-    /**
-     * Internal routes for worker services.
-     * These route `/_svc/{serviceName}/workers/{entry}/{handler}` to the worker function.
-     */
-    workers: Route[];
-}
-export type ConfiguredServicesType = 'experimentalServices' | 'services' | 'experimentalServicesV2';
-export type ConfiguredServices = ExperimentalServices | Services;
-/**
- * A single service entry inferred from project structure.
- *
- * This is an intermediate format produced by auto-detection — it carries
- * the detection results (including `mountPath`, the inferred route mount
- * point) before they are converted into a concrete config format (V1 or V2).
- */
-export interface InferredServiceConfig {
-    /** Service root directory relative to the project root. */
-    root: string;
-    /** Framework slug, if detected. */
-    framework?: string;
-    /** Service entrypoint (file path or `module:attr` reference). */
-    entrypoint?: string;
-    /** Runtime identifier (e.g. "python", "node"). */
-    runtime?: string;
-    /** Service type (e.g. "web", "cron", "worker"). */
-    type?: ServiceType;
-    /** Build command override. */
-    buildCommand?: string;
-    /** Pre-deploy command override. */
-    preDeployCommand?: string;
-    /**
-     * Inferred route mount path for this service.
-     * For example, `"/"` for the root frontend, `"/_/backend"` for a backend.
-     */
-    mountPath?: string;
-}
-export type InferredServicesConfig = Record<string, InferredServiceConfig>;
-export interface ResolvedServicesResult {
-    services: Service[];
-    source: DetectServicesSource;
-    useImplicitEnvInjection: boolean;
-    routes: ServicesRoutes;
-    /** Top-level service-targeted rewrites (V2). */
-    rewrites: Rewrite[];
-    /** V2 services config for the build output, so the platform activates V2 routing. */
-    experimentalServicesV2?: Services;
-    errors: ServiceDetectionError[];
-    warnings: ServiceDetectionWarning[];
-}
-export interface InferredServicesResult {
-    source: 'layout' | 'procfile' | 'railway' | 'render';
-    config: InferredServicesConfig;
-    services: Service[];
-    warnings: ServiceDetectionWarning[];
-}
-export interface DetectServicesResult extends ResolvedServicesResult {
-    /**
-     * Source of service definitions:
-     * - `configured`: loaded from explicit project configuration (`vercel.json#experimentalServices`, `vercel.json#services`, or the deprecated `vercel.json#experimentalServicesV2` alias)
-     * - `auto-detected`: inferred from project structure
-     */
-    resolved: ResolvedServicesResult;
-    inferred: InferredServicesResult | null;
-}
-export type DetectServicesSource = 'configured' | 'auto-detected';
-export interface ServiceDetectionWarning {
-    code: string;
-    message: string;
-    serviceName?: string;
-}
-export interface ServiceDetectionError {
-    code: string;
-    message: string;
-    serviceName?: string;
-}
-export declare const RUNTIME_BUILDERS: Record<ServiceRuntime, string>;
-export declare const RUNTIME_MANIFESTS: Partial<Record<ServiceRuntime, string[]>>;
-export declare const ENTRYPOINT_EXTENSIONS: Record<string, ServiceRuntime>;
-/**
- * Builders that produce static output (SPAs, static sites).
- * These don't have a "runtime" - they just build to static files.
- */
-export declare const STATIC_BUILDERS: Set<string>;
-/**
- * Builders that produce their own full route table with handle phases
- * (filesystem, miss, rewrite, hit, error).
- *
- * In services mode we generally avoid generating synthetic catch-all routes
- * for builders that provide their own routing. At service-detection time we
- * only have the builder "use" string (not the loaded module), so this is an
- * explicit allow-list for known route-table builders.
- *
- * NOTE: This is an explicit positive set because we can't check
- * `builder.version` at service detection time.
- */
-export declare const ROUTE_OWNING_BUILDERS: Set<string>;

package/dist/services/types.js

@@ -1,77 +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 types_exports = {};
-__export(types_exports, {
-  ENTRYPOINT_EXTENSIONS: () => ENTRYPOINT_EXTENSIONS,
-  ROUTE_OWNING_BUILDERS: () => ROUTE_OWNING_BUILDERS,
-  RUNTIME_BUILDERS: () => RUNTIME_BUILDERS,
-  RUNTIME_MANIFESTS: () => RUNTIME_MANIFESTS,
-  STATIC_BUILDERS: () => STATIC_BUILDERS
-});
-module.exports = __toCommonJS(types_exports);
-const RUNTIME_BUILDERS = {
-  node: "@vercel/backends",
-  python: "@vercel/python",
-  go: "@vercel/go",
-  rust: "@vercel/rust",
-  ruby: "@vercel/ruby",
-  container: "@vercel/container"
-};
-const 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"]
-};
-const ENTRYPOINT_EXTENSIONS = {
-  ".ts": "node",
-  ".mts": "node",
-  ".js": "node",
-  ".mjs": "node",
-  ".cjs": "node",
-  ".py": "python",
-  ".go": "go",
-  ".rs": "rust",
-  ".rb": "ruby",
-  ".ru": "ruby"
-};
-const STATIC_BUILDERS = /* @__PURE__ */ new Set([
-  "@vercel/static-build",
-  "@vercel/static"
-]);
-const ROUTE_OWNING_BUILDERS = /* @__PURE__ */ new Set([
-  "@vercel/next",
-  "@vercel/backends"
-]);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ENTRYPOINT_EXTENSIONS,
-  ROUTE_OWNING_BUILDERS,
-  RUNTIME_BUILDERS,
-  RUNTIME_MANIFESTS,
-  STATIC_BUILDERS
-});

package/dist/services/utils.d.ts

@@ -1,95 +0,0 @@
-import { INTERNAL_SERVICE_PREFIX, getInternalServiceFunctionPath, getInternalServiceCronPathPrefix, getInternalServiceCronPath } from '@vercel/build-utils';
-import type { Framework } from '@vercel/frameworks';
-import type { DetectorFilesystem } from '../detectors/filesystem';
-import type { ServiceRuntime, ExperimentalServices, ExperimentalServicesV2, InferredServicesConfig, Services, ServiceDetectionError, ServiceDetectionWarning, ResolvedService } from './types';
-export declare const DETECTION_FRAMEWORKS: Framework[];
-export { INTERNAL_SERVICE_PREFIX, getInternalServiceFunctionPath, getInternalServiceCronPathPrefix, getInternalServiceCronPath, };
-/**
- * Removes a trailing slash from an already-`posixPath.normalize`d path.
- *
- * `posixPath.normalize` preserves trailing slashes (`"frontend/"` stays
- * `"frontend/"`), which double-prefixes builder paths when the value is later
- * used as both `builder.config.workspace` and a `posixPath.join` prefix. Strip
- * it so `"frontend/"` and `"frontend"` resolve identically. An empty result or
- * a lone `"/"` collapses to `"."` (matching `normalizeServiceEntrypoint`).
- */
-export declare function stripTrailingSlash(p: string): string;
-export declare function hasFile(fs: DetectorFilesystem, filePath: string): Promise<boolean>;
-/**
- * Reserved internal namespace used by the dev queue proxy.
- */
-export declare const INTERNAL_QUEUES_PREFIX = "/_svc/_queues";
-export declare function getInternalServiceWorkerPathPrefix(serviceName: string): string;
-export declare function getInternalServiceWorkerPath(serviceName: string, entrypoint: string, handler?: string): string;
-export declare function getBuilderForRuntime(runtime: ServiceRuntime): string;
-export declare function isStaticBuild(service: ResolvedService): boolean;
-/**
- * Determines if a service uses a "route-owning" builder.
- *
- * Route-owning builders (e.g., `@vercel/next`, `@vercel/backends`) produce
- * their own full route table with handle phases (filesystem, miss, rewrite,
- * hit, error). The services system should NOT generate synthetic catch-all
- * rewrites for them — instead, we rely on the builder's own `routes[]`.
- */
-export declare function isRouteOwningBuilder(service: ResolvedService): boolean;
-/**
- * Infer runtime from a framework slug.
- *
- * Examples:
- * - `python` -> `python`
- * - `fastapi` -> `python`
- * - `express` -> `node`
- */
-export declare function inferRuntimeFromFramework(framework: string | null | undefined): ServiceRuntime | undefined;
-export declare function isFrontendFramework(framework: string | null | undefined): boolean;
-export declare function isBFFFramework(framework: string | null | undefined): boolean;
-export declare function filterFrameworksByRuntime<T extends {
-    slug?: string | null;
-}>(frameworks: readonly T[], runtime?: ServiceRuntime): T[];
-/**
- * Infer runtime from available service configuration.
- *
- * Priority (highest to lowest):
- * 1. Explicit runtime (user specified in config)
- * 2. Runtime framework slug (ruby → ruby, go → go)
- * 3. Framework detection (fastapi → python, express → node)
- * 4. Builder detection (@vercel/python → python)
- * 5. Entrypoint extension (.py → python, .ts → node)
- *
- * @returns The inferred runtime, or undefined if none can be determined.
- */
-export declare function inferServiceRuntime(config: {
-    runtime?: string;
-    framework?: string;
-    builder?: string;
-    entrypoint?: string;
-}): ServiceRuntime | undefined;
-export interface ReadVercelConfigResult {
-    config: {
-        experimentalServices?: ExperimentalServices;
-        services?: Services;
-        experimentalServicesV2?: ExperimentalServicesV2;
-    } | null;
-    error: ServiceDetectionError | null;
-}
-/**
- * Read and parse vercel.json or vercel.toml from filesystem.
- * Returns the parsed config or an error if the file exists but is invalid.
- */
-export declare function readVercelConfig(fs: DetectorFilesystem): Promise<ReadVercelConfigResult>;
-/**
- * Assign mount paths to inferred services.
- *
- * A frontend service gets `/`, backend services get `/api/...`:
- * - If the frontend is a BFF (e.g. Next.js, has its own API routes):
- *   backends get `/api/{name}/(.*)` to avoid shadowing the frontend's API routes.
- * - If the frontend is client-only (e.g. Vite):
- *   backends get `/api/(.*)`.
- *
- * A single non-frontend service gets `/`.
- * If no frontend service found, multiple services get `/api/{name}`.
- *
- * Priority for `/`: single service or frontend > name "frontend" or "web" > alphabetical.
- */
-export declare function assignMountPaths(services: InferredServicesConfig): ServiceDetectionWarning[];
-export declare function combineBuildCommand(buildCommand: string | undefined, preDeployCommand: string | string[] | undefined): string | undefined;

package/dist/services/utils.js

@@ -1,265 +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 utils_exports = {};
-__export(utils_exports, {
-  DETECTION_FRAMEWORKS: () => DETECTION_FRAMEWORKS,
-  INTERNAL_QUEUES_PREFIX: () => INTERNAL_QUEUES_PREFIX,
-  INTERNAL_SERVICE_PREFIX: () => import_build_utils.INTERNAL_SERVICE_PREFIX,
-  assignMountPaths: () => assignMountPaths,
-  combineBuildCommand: () => combineBuildCommand,
-  filterFrameworksByRuntime: () => filterFrameworksByRuntime,
-  getBuilderForRuntime: () => getBuilderForRuntime,
-  getInternalServiceCronPath: () => import_build_utils.getInternalServiceCronPath,
-  getInternalServiceCronPathPrefix: () => import_build_utils.getInternalServiceCronPathPrefix,
-  getInternalServiceFunctionPath: () => import_build_utils.getInternalServiceFunctionPath,
-  getInternalServiceWorkerPath: () => getInternalServiceWorkerPath,
-  getInternalServiceWorkerPathPrefix: () => getInternalServiceWorkerPathPrefix,
-  hasFile: () => hasFile,
-  inferRuntimeFromFramework: () => inferRuntimeFromFramework,
-  inferServiceRuntime: () => inferServiceRuntime,
-  isBFFFramework: () => isBFFFramework,
-  isFrontendFramework: () => isFrontendFramework,
-  isRouteOwningBuilder: () => isRouteOwningBuilder,
-  isStaticBuild: () => isStaticBuild,
-  readVercelConfig: () => readVercelConfig,
-  stripTrailingSlash: () => stripTrailingSlash
-});
-module.exports = __toCommonJS(utils_exports);
-var import_framework_helpers = require("@vercel/build-utils/dist/framework-helpers");
-var import_build_utils = require("@vercel/build-utils");
-var import_frameworks = require("@vercel/frameworks");
-var import_types = require("./types");
-const DETECTION_FRAMEWORKS = import_frameworks.frameworkList.filter(
-  (framework) => !framework.experimental || framework.runtimeFramework
-);
-function stripTrailingSlash(p) {
-  const stripped = p.replace(/\/+$/, "");
-  return stripped === "" ? "." : stripped;
-}
-async function hasFile(fs, filePath) {
-  try {
-    return await fs.isFile(filePath);
-  } catch {
-    return false;
-  }
-}
-const INTERNAL_QUEUES_PREFIX = "/_svc/_queues";
-function normalizeInternalServiceEntrypoint(entrypoint) {
-  const normalized = entrypoint.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\.[^/.]+$/, "");
-  return normalized || "index";
-}
-function getInternalServiceWorkerPathPrefix(serviceName) {
-  return `${import_build_utils.INTERNAL_SERVICE_PREFIX}/${serviceName}/workers`;
-}
-function getInternalServiceWorkerPath(serviceName, entrypoint, handler = "worker") {
-  const normalizedEntrypoint = normalizeInternalServiceEntrypoint(entrypoint);
-  return `${getInternalServiceWorkerPathPrefix(serviceName)}/${normalizedEntrypoint}/${handler}`;
-}
-function getBuilderForRuntime(runtime) {
-  const builder = import_types.RUNTIME_BUILDERS[runtime];
-  if (!builder) {
-    throw new Error(`Unknown runtime: ${runtime}`);
-  }
-  return builder;
-}
-function isStaticBuild(service) {
-  return import_types.STATIC_BUILDERS.has(service.builder.use);
-}
-function isRouteOwningBuilder(service) {
-  return import_types.ROUTE_OWNING_BUILDERS.has(service.builder.use);
-}
-function inferRuntimeFromFramework(framework) {
-  if (!framework) {
-    return void 0;
-  }
-  if (framework in import_types.RUNTIME_BUILDERS) {
-    return framework;
-  }
-  if ((0, import_framework_helpers.isPythonFramework)(framework)) {
-    return "python";
-  }
-  if ((0, import_framework_helpers.isBackendFramework)(framework)) {
-    return "node";
-  }
-  return void 0;
-}
-function isFrontendFramework(framework) {
-  if (!framework) {
-    return false;
-  }
-  return !inferRuntimeFromFramework(framework);
-}
-const BFF_FRAMEWORKS = /* @__PURE__ */ new Set([
-  "nextjs",
-  "nuxtjs",
-  "sveltekit",
-  "remix",
-  "solidstart"
-]);
-function isBFFFramework(framework) {
-  return !!framework && BFF_FRAMEWORKS.has(framework);
-}
-function filterFrameworksByRuntime(frameworks, runtime) {
-  if (!runtime) {
-    return [...frameworks];
-  }
-  return frameworks.filter(
-    (framework) => inferRuntimeFromFramework(framework.slug) === runtime
-  );
-}
-function inferServiceRuntime(config) {
-  if (config.runtime && config.runtime in import_types.RUNTIME_BUILDERS) {
-    return config.runtime;
-  }
-  const frameworkRuntime = inferRuntimeFromFramework(config.framework);
-  if (frameworkRuntime) {
-    return frameworkRuntime;
-  }
-  if (config.builder) {
-    for (const [runtime, builderName] of Object.entries(import_types.RUNTIME_BUILDERS)) {
-      if (config.builder === builderName) {
-        return runtime;
-      }
-    }
-  }
-  if (config.entrypoint) {
-    if (config.entrypoint === "pyproject.toml" || config.entrypoint.endsWith("/pyproject.toml")) {
-      return "python";
-    }
-    for (const [ext, runtime] of Object.entries(import_types.ENTRYPOINT_EXTENSIONS)) {
-      if (config.entrypoint.endsWith(ext)) {
-        return runtime;
-      }
-    }
-  }
-  return void 0;
-}
-async function readVercelConfig(fs) {
-  const hasVercelJson = await fs.hasPath("vercel.json");
-  if (hasVercelJson) {
-    try {
-      const content = await fs.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."
-        }
-      };
-    }
-  }
-  const hasVercelToml = await fs.hasPath("vercel.toml");
-  if (hasVercelToml) {
-    try {
-      const { parse: tomlParse } = await import("smol-toml");
-      const content = await fs.readFile("vercel.toml");
-      const config = tomlParse(content.toString());
-      return { config, error: null };
-    } catch {
-      return {
-        config: null,
-        error: {
-          code: "INVALID_VERCEL_TOML",
-          message: "Failed to parse vercel.toml. Ensure it contains valid TOML."
-        }
-      };
-    }
-  }
-  return { config: null, error: null };
-}
-function assignMountPaths(services) {
-  const warnings = [];
-  const names = Object.keys(services);
-  if (names.length === 1) {
-    services[names[0]].mountPath = "/";
-    return warnings;
-  }
-  const frontendNames = names.filter(
-    (name) => isFrontendFramework(services[name].framework)
-  );
-  let rootName = null;
-  if (frontendNames.length === 1) {
-    rootName = frontendNames[0];
-  } else if (frontendNames.length > 1) {
-    rootName = frontendNames.find((n) => n === "frontend" || n === "web") ?? frontendNames.sort()[0];
-    warnings.push({
-      code: "MULTIPLE_FRONTENDS",
-      message: `Multiple frontend services detected (${frontendNames.join(", ")}). "${rootName}" was assigned mount path "/". Adjust manually if a different service should be the root.`
-    });
-  }
-  const rootFramework = rootName ? services[rootName].framework : void 0;
-  const isBFF = rootFramework ? isBFFFramework(rootFramework) : false;
-  const nonRootNames = names.filter((n) => n !== rootName);
-  const needsNamespace = isBFF || nonRootNames.length > 1;
-  for (const name of names) {
-    if (name === rootName) {
-      services[name].mountPath = "/";
-    } else {
-      services[name].mountPath = needsNamespace ? `/api/${name}` : "/api";
-    }
-  }
-  return warnings;
-}
-function combineBuildCommand(buildCommand, preDeployCommand) {
-  const preDeploy = Array.isArray(preDeployCommand) ? preDeployCommand.join(" && ") : preDeployCommand;
-  if (preDeploy && buildCommand) {
-    return `${buildCommand} && ${preDeploy}`;
-  } else if (preDeploy) {
-    return preDeploy;
-  } else {
-    return buildCommand;
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DETECTION_FRAMEWORKS,
-  INTERNAL_QUEUES_PREFIX,
-  INTERNAL_SERVICE_PREFIX,
-  assignMountPaths,
-  combineBuildCommand,
-  filterFrameworksByRuntime,
-  getBuilderForRuntime,
-  getInternalServiceCronPath,
-  getInternalServiceCronPathPrefix,
-  getInternalServiceFunctionPath,
-  getInternalServiceWorkerPath,
-  getInternalServiceWorkerPathPrefix,
-  hasFile,
-  inferRuntimeFromFramework,
-  inferServiceRuntime,
-  isBFFFramework,
-  isFrontendFramework,
-  isRouteOwningBuilder,
-  isStaticBuild,
-  readVercelConfig,
-  stripTrailingSlash
-});