@vercel/static-build 2.9.7 → 2.9.9

package/dist/index.js

@@ -11131,6 +11131,34 @@ var require_frameworks = __commonJS({
         },
         getOutputDirName: async () => "public"
       },
+      {
+        name: "Mastra",
+        slug: "mastra",
+        logo: "https://api-frameworks.vercel.sh/framework-logos/mastra.svg",
+        darkModeLogo: "https://api-frameworks.vercel.sh/framework-logos/mastra-dark.svg",
+        tagline: "Build AI agents with a modern TypeScript stack",
+        description: "Mastra is a framework for building AI-powered apps and agents with workflows, memory, streaming, evals, tracing, and Studio, an interactive UI for dev and testing.",
+        website: "https://mastra.ai",
+        detectors: {
+          every: [{ matchPackage: "mastra" }]
+        },
+        settings: {
+          installCommand: {
+            placeholder: "`yarn install`, `pnpm install`, `npm install`, or `bun install`"
+          },
+          buildCommand: {
+            placeholder: "`npm run build` or `mastra build`",
+            value: "mastra build"
+          },
+          devCommand: {
+            value: "mastra dev"
+          },
+          outputDirectory: {
+            value: ".mastra"
+          }
+        },
+        getOutputDirName: async () => ".mastra"
+      },
       {
         name: "Other",
         slug: null,
@@ -22453,6 +22481,278 @@ var require_auto_detect = __commonJS({
   }
 });
 
+// ../fs-detectors/dist/services/detect-railway.js
+var require_detect_railway = __commonJS({
+  "../fs-detectors/dist/services/detect-railway.js"(exports, 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_railway_exports = {};
+    __export2(detect_railway_exports, {
+      detectRailwayServices: () => detectRailwayServices
+    });
+    module2.exports = __toCommonJS2(detect_railway_exports);
+    var import_path7 = require("path");
+    var import_smol_toml = __toESM2(require_dist());
+    var import_frameworks2 = require_frameworks();
+    var import_detect_framework = require_detect_framework();
+    var import_utils = require_utils4();
+    var RAILWAY_JSON = "railway.json";
+    var RAILWAY_TOML = "railway.toml";
+    var MAX_SCAN_DEPTH = 5;
+    var SKIP_DIRS = /* @__PURE__ */ new Set([
+      ".hg",
+      ".git",
+      ".svn",
+      ".cache",
+      ".next",
+      ".now",
+      ".vercel",
+      ".venv",
+      ".yarn",
+      ".turbo",
+      ".output",
+      "node_modules",
+      "__pycache__",
+      "venv",
+      "CVS"
+    ]);
+    var DETECTION_FRAMEWORKS = import_frameworks2.frameworkList.filter(
+      (framework) => !framework.experimental || framework.runtimeFramework
+    );
+    async function detectRailwayServices(options) {
+      const { fs: fs5 } = options;
+      const { configs, warnings } = await findRailwayConfigs(fs5);
+      if (configs.length === 0) {
+        return { services: null, errors: [], warnings };
+      }
+      const services = {};
+      const serviceDirs = /* @__PURE__ */ new Map();
+      const errors = [];
+      for (const cf of configs) {
+        const serviceFs = cf.dirPath === "." ? fs5 : fs5.chdir(cf.dirPath);
+        const dirLabel = cf.dirPath === "." ? "root" : cf.dirPath;
+        const frameworks2 = await (0, import_detect_framework.detectFrameworks)({
+          fs: serviceFs,
+          frameworkList: DETECTION_FRAMEWORKS,
+          useExperimentalFrameworks: true
+        });
+        if (cf.config.deploy?.cronSchedule) {
+          const schedule = cf.config.deploy.cronSchedule;
+          const runtime = frameworks2.length === 1 ? (0, import_utils.inferRuntimeFromFramework)(frameworks2[0].slug) : void 0;
+          const hint = {
+            type: "cron",
+            schedule,
+            entrypoint: "<path-to-handler>"
+          };
+          if (runtime) {
+            hint.runtime = runtime;
+          }
+          warnings.push({
+            code: "RAILWAY_CRON_HINT",
+            message: `Found Railway cron in ${dirLabel}/ (schedule: "${schedule}"). Vercel crons work with a file entrypoint. You can add the following to define this cron service:
+"${deriveServiceName(cf.dirPath)}": ${JSON.stringify(hint, null, 2)}`
+          });
+          continue;
+        }
+        const serviceName = deriveServiceName(cf.dirPath);
+        const existingDir = serviceDirs.get(serviceName);
+        if (existingDir) {
+          errors.push({
+            code: "DUPLICATE_SERVICE",
+            message: `Duplicate service name "${serviceName}" derived from ${existingDir}/ and ${dirLabel}/. Rename one of the directories to avoid conflicts.`,
+            serviceName
+          });
+          continue;
+        }
+        serviceDirs.set(serviceName, dirLabel);
+        if (frameworks2.length === 0) {
+          warnings.push({
+            code: "SERVICE_SKIPPED",
+            message: `Skipped service in ${dirLabel}/: no framework detected. Configure it manually in experimentalServices.`
+          });
+          continue;
+        }
+        if (frameworks2.length > 1) {
+          const names = frameworks2.map((f) => f.name).join(", ");
+          errors.push({
+            code: "MULTIPLE_FRAMEWORKS_SERVICE",
+            message: `Multiple frameworks detected in ${dirLabel}/: ${names}. Use explicit experimentalServices config.`,
+            serviceName
+          });
+          continue;
+        }
+        const framework = frameworks2[0];
+        let serviceConfig = {};
+        serviceConfig.framework = framework.slug ?? void 0;
+        if (cf.dirPath !== ".") {
+          serviceConfig.entrypoint = cf.dirPath;
+        }
+        const buildCommand = combineBuildCommand(
+          cf.config.build?.buildCommand,
+          cf.config.deploy?.preDeployCommand
+        );
+        if (buildCommand) {
+          serviceConfig.buildCommand = buildCommand;
+        }
+        services[serviceName] = serviceConfig;
+      }
+      if (errors.length > 0) {
+        return { services: null, errors, warnings };
+      }
+      const serviceNames = Object.keys(services);
+      if (serviceNames.length === 0) {
+        return { services: null, errors: [], warnings };
+      }
+      warnings.push(...assignRoutePrefixes(services));
+      return { services, errors: [], warnings };
+    }
+    async function findRailwayConfigs(fs5, dirPath = ".", depth = 0) {
+      const configs = [];
+      const warnings = [];
+      const readResult = await readRailwayConfigRaw(fs5, dirPath);
+      warnings.push(...readResult.warnings);
+      const { config, warning } = tryParseRailwayConfig(readResult.raw);
+      if (warning) {
+        warnings.push(warning);
+      }
+      if (config) {
+        configs.push({ dirPath, config });
+      }
+      if (depth >= MAX_SCAN_DEPTH) {
+        return { configs, warnings };
+      }
+      const readPath = dirPath === "." ? "/" : dirPath;
+      let entries;
+      try {
+        entries = await fs5.readdir(readPath);
+      } catch {
+        return { configs, warnings };
+      }
+      for (const entry of entries) {
+        if (entry.type !== "dir" || SKIP_DIRS.has(entry.name)) {
+          continue;
+        }
+        const childPath = dirPath === "." ? entry.name : import_path7.posix.join(dirPath, entry.name);
+        const child = await findRailwayConfigs(fs5, childPath, depth + 1);
+        configs.push(...child.configs);
+        warnings.push(...child.warnings);
+      }
+      return { configs, warnings };
+    }
+    async function readRailwayConfigRaw(fs5, dirPath) {
+      const warnings = [];
+      for (const filename of [RAILWAY_JSON, RAILWAY_TOML]) {
+        const filePath = dirPath === "." ? filename : import_path7.posix.join(dirPath, filename);
+        try {
+          const exists = await fs5.isFile(filePath);
+          if (!exists)
+            continue;
+        } catch {
+          continue;
+        }
+        try {
+          const buf = await fs5.readFile(filePath);
+          return {
+            raw: { path: filePath, content: buf.toString("utf-8") },
+            warnings
+          };
+        } catch (err) {
+          warnings.push({
+            code: "RAILWAY_CONFIG_ERROR",
+            message: `Failed to read ${filePath}: ${err instanceof Error ? err.message : String(err)}`
+          });
+        }
+      }
+      return { raw: null, warnings };
+    }
+    function tryParseRailwayConfig(raw) {
+      if (!raw) {
+        return { config: null };
+      }
+      try {
+        const config = raw.path.endsWith(".toml") ? import_smol_toml.default.parse(raw.content) : JSON.parse(raw.content);
+        return { config };
+      } catch (err) {
+        return {
+          config: null,
+          warning: {
+            code: "RAILWAY_PARSE_ERROR",
+            message: `Failed to parse ${raw.path}: ${err instanceof Error ? err.message : String(err)}`
+          }
+        };
+      }
+    }
+    function deriveServiceName(dirPath) {
+      if (dirPath === ".") {
+        return "web";
+      }
+      const segments = dirPath.split("/");
+      return segments[segments.length - 1];
+    }
+    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;
+      }
+    }
+    function assignRoutePrefixes(services) {
+      const warnings = [];
+      const names = Object.keys(services);
+      if (names.length === 1) {
+        services[names[0]].routePrefix = "/";
+        return warnings;
+      }
+      const frontendNames = names.filter(
+        (name) => (0, import_utils.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 routePrefix "/". Adjust manually if a different service should be the root.`
+        });
+      }
+      for (const name of names) {
+        services[name].routePrefix = name === rootName ? "/" : `/_/${name}`;
+      }
+      return warnings;
+    }
+  }
+});
+
 // ../fs-detectors/dist/services/detect-services.js
 var require_detect_services = __commonJS({
   "../fs-detectors/dist/services/detect-services.js"(exports, module2) {
@@ -22484,6 +22784,7 @@ var require_detect_services = __commonJS({
     var import_utils = require_utils4();
     var import_resolve = require_resolve();
     var import_auto_detect = require_auto_detect();
+    var import_detect_railway = require_detect_railway();
     var PREVIEW_DOMAIN_MISSING = [
       { type: "host", value: { suf: ".vercel.app" } },
       { type: "host", value: { suf: ".vercel.dev" } }
@@ -22521,6 +22822,9 @@ var require_detect_services = __commonJS({
         if ((0, import_utils.isFrontendFramework)(service.framework)) {
           serviceConfig.framework = service.framework;
         }
+        if (typeof service.buildCommand === "string") {
+          serviceConfig.buildCommand = service.buildCommand;
+        }
         inferredConfig[name] = serviceConfig;
       }
       return inferredConfig;
@@ -22541,17 +22845,41 @@ var require_detect_services = __commonJS({
       const configuredServices = vercelConfig?.experimentalServices;
       const hasConfiguredServices = configuredServices && Object.keys(configuredServices).length > 0;
       if (!hasConfiguredServices) {
-        const autoResult = await (0, import_auto_detect.autoDetectServices)({ fs: scopedFs });
-        if (autoResult.errors.length > 0) {
+        const railwayResult = await (0, import_detect_railway.detectRailwayServices)({ fs: scopedFs });
+        if (railwayResult.errors.length > 0) {
           return withResolvedResult({
             services: [],
             source: "auto-detected",
             routes: emptyRoutes(),
-            errors: autoResult.errors,
-            warnings: []
+            errors: railwayResult.errors,
+            warnings: railwayResult.warnings
           });
         }
-        if (autoResult.services) {
+        if (railwayResult.services) {
+          const result2 = await (0, import_resolve.resolveAllConfiguredServices)(
+            railwayResult.services,
+            scopedFs,
+            "generated"
+          );
+          const inferred = result2.errors.length === 0 && result2.services.length > 0 ? {
+            source: "railway",
+            config: toInferredLayoutConfig(railwayResult.services),
+            services: result2.services,
+            warnings: railwayResult.warnings
+          } : null;
+          return withResolvedResult(
+            {
+              services: [],
+              source: "auto-detected",
+              routes: emptyRoutes(),
+              errors: result2.errors,
+              warnings: railwayResult.warnings
+            },
+            inferred
+          );
+        }
+        const autoResult = await (0, import_auto_detect.autoDetectServices)({ fs: scopedFs });
+        if (autoResult.services && autoResult.errors.length === 0) {
           const result2 = await (0, import_resolve.resolveAllConfiguredServices)(
             autoResult.services,
             scopedFs,
@@ -22575,6 +22903,14 @@ var require_detect_services = __commonJS({
             warnings: []
           } : null;
           return withResolvedResult(resolved, inferred);
+        } else if (autoResult.errors.length > 0) {
+          return withResolvedResult({
+            services: [],
+            source: "auto-detected",
+            routes: emptyRoutes(),
+            errors: autoResult.errors,
+            warnings: []
+          });
         }
         return withResolvedResult({
           services: [],
@@ -31076,6 +31412,15 @@ var require_get_monorepo_default_settings = __commonJS({
       }
       return !import_semver2.default.intersects(turboSemVer, "<1.8.0");
     }
+    function supportsFilter(turboSemVer) {
+      if (!turboSemVer) {
+        return true;
+      }
+      if (!import_semver2.default.validRange(turboSemVer)) {
+        return true;
+      }
+      return !import_semver2.default.intersects(turboSemVer, "<=1.1.0");
+    }
     async function getMonorepoDefaultSettings(projectName, projectPath, relativeToRoot, detectorFilesystem) {
       const [monorepoManager, packageManager] = await Promise.all([
         (0, import_detect_framework.detectFramework)({
@@ -31126,8 +31471,10 @@ var require_get_monorepo_default_settings = __commonJS({
         if (projectPath) {
           if (supportsRootCommand(turboSemVer)) {
             buildCommand = `turbo run build`;
-          } else {
+          } else if (supportsFilter(turboSemVer)) {
             buildCommand = `cd ${relativeToRoot} && turbo run build --filter={${projectPath}}...`;
+          } else {
+            buildCommand = `cd ${relativeToRoot} && turbo run build --scope=${projectName}`;
           }
         }
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/static-build",
-  "version": "2.9.7",
+  "version": "2.9.9",
   "license": "Apache-2.0",
   "main": "./dist/index",
   "homepage": "https://vercel.com/docs/build-step",
@@ -14,8 +14,8 @@
   },
   "dependencies": {
     "ts-morph": "12.0.0",
+    "@vercel/gatsby-plugin-vercel-builder": "2.1.9",
     "@vercel/gatsby-plugin-vercel-analytics": "1.0.11",
-    "@vercel/gatsby-plugin-vercel-builder": "2.1.7",
     "@vercel/static-config": "3.2.0"
   },
   "devDependencies": {
@@ -38,11 +38,11 @@
     "rc9": "1.2.0",
     "semver": "7.5.2",
     "tree-kill": "1.2.2",
-    "@vercel/build-utils": "13.12.1",
-    "@vercel/frameworks": "3.22.0",
     "@vercel/error-utils": "2.0.3",
+    "@vercel/frameworks": "3.23.0",
+    "@vercel/fs-detectors": "5.14.3",
     "@vercel/routing-utils": "6.1.1",
-    "@vercel/fs-detectors": "5.13.0"
+    "@vercel/build-utils": "13.13.0"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",