@vercel/fs-detectors 7.6.1 → 7.7.0

package/dist/detect-builders.d.ts

@@ -27,6 +27,13 @@ export interface ProxyConfig {
 export interface Options {
     tag?: string;
     functions?: BuilderFunctions;
+    /**
+     * Source files built by a builder that detection does not create itself
+     * (e.g. schedule entrypoints resolved by the CLI). Detection neither builds
+     * them as `api/` functions nor serves them as static files, and `functions`
+     * patterns that match them count as used.
+     */
+    reservedFunctionFiles?: string[];
     ignoreBuildScript?: boolean;
     projectSettings?: ProjectSettings;
     cleanUrls?: boolean;

package/dist/detect-builders.js

@@ -5,6 +5,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -26,6 +29,272 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../internals/runtimes/dist/constants.js
+var require_constants = __commonJS({
+  "../../internals/runtimes/dist/constants.js"(exports, 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 constants_exports = {};
+    __export2(constants_exports, {
+      BUILDER_RUNTIMES: () => BUILDER_RUNTIMES,
+      CONTAINER_ENTRYPOINT_CANDIDATES: () => CONTAINER_ENTRYPOINT_CANDIDATES,
+      ENTRYPOINT_EXTENSIONS: () => ENTRYPOINT_EXTENSIONS2,
+      ROUTE_OWNING_BUILDERS: () => ROUTE_OWNING_BUILDERS,
+      RUNTIME_BUILDERS: () => RUNTIME_BUILDERS,
+      RUNTIME_MANIFESTS: () => RUNTIME_MANIFESTS,
+      STATIC_BUILDERS: () => STATIC_BUILDERS
+    });
+    module2.exports = __toCommonJS2(constants_exports);
+    var RUNTIME_BUILDERS = {
+      node: "@vercel/backends",
+      python: "@vercel/python",
+      go: "@vercel/go",
+      rust: "@vercel/rust",
+      ruby: "@vercel/ruby",
+      container: "@vercel/container"
+    };
+    var RUNTIME_MANIFESTS = {
+      node: ["package.json"],
+      python: [
+        "pyproject.toml",
+        "requirements.txt",
+        "Pipfile",
+        "pylock.yml",
+        "uv.lock",
+        "setup.py"
+      ],
+      go: ["go.mod"],
+      ruby: ["Gemfile"],
+      rust: ["Cargo.toml"]
+    };
+    var ENTRYPOINT_EXTENSIONS2 = {
+      ".ts": "node",
+      ".mts": "node",
+      ".js": "node",
+      ".mjs": "node",
+      ".cjs": "node",
+      ".py": "python",
+      ".go": "go",
+      ".rs": "rust",
+      ".rb": "ruby",
+      ".ru": "ruby"
+    };
+    var BUILDER_RUNTIMES = Object.fromEntries(
+      Object.entries(RUNTIME_BUILDERS).map(([runtime, builder]) => [
+        builder,
+        runtime
+      ])
+    );
+    var STATIC_BUILDERS = /* @__PURE__ */ new Set([
+      "@vercel/static-build",
+      "@vercel/static"
+    ]);
+    var ROUTE_OWNING_BUILDERS = /* @__PURE__ */ new Set([
+      "@vercel/next",
+      "@vercel/backends"
+    ]);
+    var CONTAINER_ENTRYPOINT_CANDIDATES = [
+      "Dockerfile.vercel",
+      "Containerfile.vercel",
+      "Dockerfile",
+      "Containerfile"
+    ];
+  }
+});
+
+// ../../internals/runtimes/dist/entrypoint.js
+var require_entrypoint = __commonJS({
+  "../../internals/runtimes/dist/entrypoint.js"(exports, 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 entrypoint_exports = {};
+    __export2(entrypoint_exports, {
+      SCHEDULE_ENTRYPOINT_FORMS_HINT: () => SCHEDULE_ENTRYPOINT_FORMS_HINT,
+      isDockerfileEntrypoint: () => isDockerfileEntrypoint,
+      parsePyModuleAttrEntrypoint: () => parsePyModuleAttrEntrypoint2,
+      parseScheduleEntrypoint: () => parseScheduleEntrypoint,
+      stripTrailingSlash: () => stripTrailingSlash
+    });
+    module2.exports = __toCommonJS2(entrypoint_exports);
+    var import_path2 = require("path");
+    var import_constants2 = require_constants();
+    var PYTHON_MODULE_ATTR_RE = /^([A-Za-z_][\w]*(?:\.[A-Za-z_][\w]*)*):([A-Za-z_][\w]*)$/;
+    var NODE_FILE_ENTRYPOINT_RE = /^(?!\/)(?!.*(?:^|\/)\.\.?(?:\/|$))(?:[\w@+.-]+\/)*[\w@+.-]+\.[cm]?[jt]s$/;
+    var NODE_DECLARATION_ENTRYPOINT_RE = /\.d\.[cm]?ts$/;
+    function parsePyModuleAttrEntrypoint2(entrypoint) {
+      const match = PYTHON_MODULE_ATTR_RE.exec(entrypoint);
+      if (!match)
+        return null;
+      const [, modulePart, attrName] = match;
+      if (!modulePart || !attrName)
+        return null;
+      return {
+        attrName,
+        filePath: modulePart.replace(/\./g, "/") + ".py",
+        moduleName: modulePart
+      };
+    }
+    var SCHEDULE_ENTRYPOINT_FORMS_HINT = 'Use a source file path like "jobs/nightly.ts" or a Python "module.path:function" reference.';
+    function parseScheduleEntrypoint(entrypoint) {
+      const python = parsePyModuleAttrEntrypoint2(entrypoint);
+      if (python) {
+        return { runtime: "python", ...python };
+      }
+      if (NODE_FILE_ENTRYPOINT_RE.test(entrypoint) && !NODE_DECLARATION_ENTRYPOINT_RE.test(entrypoint)) {
+        return { runtime: "node", filePath: entrypoint };
+      }
+      return null;
+    }
+    var CONTAINER_ENTRYPOINT_BASENAMES = new Set(
+      import_constants2.CONTAINER_ENTRYPOINT_CANDIDATES.map((name) => name.toLowerCase())
+    );
+    function isDockerfileEntrypoint(entrypoint) {
+      return CONTAINER_ENTRYPOINT_BASENAMES.has(
+        import_path2.posix.basename(entrypoint).toLowerCase()
+      );
+    }
+    function stripTrailingSlash(p) {
+      const stripped = p.replace(/\/+$/, "");
+      return stripped === "" ? "." : stripped;
+    }
+  }
+});
+
+// ../../internals/runtimes/dist/framework.js
+var require_framework = __commonJS({
+  "../../internals/runtimes/dist/framework.js"(exports, 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 framework_exports = {};
+    __export2(framework_exports, {
+      DETECTION_FRAMEWORKS: () => DETECTION_FRAMEWORKS,
+      filterFrameworksByRuntime: () => filterFrameworksByRuntime,
+      frameworksBySlug: () => frameworksBySlug,
+      inferBuilderRuntimeFromFramework: () => inferBuilderRuntimeFromFramework2,
+      inferRuntimeFromFramework: () => inferRuntimeFromFramework,
+      inferServerRuntimeFromFramework: () => inferServerRuntimeFromFramework,
+      isBFFFramework: () => isBFFFramework,
+      isFrontendFramework: () => isFrontendFramework
+    });
+    module2.exports = __toCommonJS2(framework_exports);
+    var import_build_utils3 = require("@vercel/build-utils");
+    var import_frameworks2 = require("@vercel/frameworks");
+    var import_constants2 = require_constants();
+    var frameworksBySlug = new Map(
+      import_frameworks2.frameworkList.flatMap((f) => typeof f.slug === "string" ? [[f.slug, f]] : [])
+    );
+    var DETECTION_FRAMEWORKS = import_frameworks2.frameworkList.filter(
+      (framework) => !framework.experimental || framework.runtimeFramework
+    );
+    function inferRuntimeFromFramework(framework) {
+      if (!framework)
+        return void 0;
+      if (framework in import_constants2.RUNTIME_BUILDERS)
+        return framework;
+      if ((0, import_build_utils3.isPythonFramework)(framework))
+        return "python";
+      if ((0, import_build_utils3.isBackendFramework)(framework))
+        return "node";
+      return void 0;
+    }
+    var STATIC_BUILDER_RUNTIMES = {
+      hugo: "go",
+      jekyll: "ruby",
+      middleman: "ruby",
+      zola: "rust"
+    };
+    function inferServerRuntimeFromFramework(framework) {
+      if (!framework || framework === "services")
+        return void 0;
+      const builder = frameworksBySlug.get(framework)?.useRuntime?.use;
+      if (!builder)
+        return void 0;
+      return import_constants2.BUILDER_RUNTIMES[builder] ?? "node";
+    }
+    function inferBuilderRuntimeFromFramework2(framework) {
+      if (!framework || framework === "container" || framework === "services")
+        return void 0;
+      const f = frameworksBySlug.get(framework);
+      const declaredBuilder = f?.useRuntime?.use;
+      if (declaredBuilder)
+        return import_constants2.BUILDER_RUNTIMES[declaredBuilder];
+      const detectorItems = [
+        ...f?.detectors?.every ?? [],
+        ...f?.detectors?.some ?? []
+      ];
+      return STATIC_BUILDER_RUNTIMES[framework] ?? (detectorItems.some((d) => d.matchPackage !== void 0) ? "node" : void 0);
+    }
+    function isFrontendFramework(framework) {
+      return !!framework && !inferRuntimeFromFramework(framework);
+    }
+    var 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((f) => inferRuntimeFromFramework(f.slug) === runtime);
+    }
+  }
+});
+
+// src/detect-builders.ts
 var detect_builders_exports = {};
 __export(detect_builders_exports, {
   REGEX_MIDDLEWARE_FILES: () => REGEX_MIDDLEWARE_FILES,
@@ -43,17 +312,53 @@ __export(detect_builders_exports, {
 });
 module.exports = __toCommonJS(detect_builders_exports);
 var import_minimatch = __toESM(require("minimatch"));
+var import_entrypoint = __toESM(require_entrypoint());
 var import_semver = require("semver");
 var import_path = require("path");
 var import_frameworks = require("@vercel/frameworks");
-var import_framework = require("@vercel-internals/runtimes/framework");
-var import_constants = require("@vercel-internals/runtimes/constants");
-var import_is_official_runtime = require("./is-official-runtime");
+var import_framework = __toESM(require_framework());
+var import_constants = __toESM(require_constants());
+
+// src/is-official-runtime.ts
+var isOfficialRuntime = (desired, name) => {
+  if (typeof name !== "string") {
+    return false;
+  }
+  return name === `@vercel/${desired}` || name === `@now/${desired}` || name.startsWith(`@vercel/${desired}@`) || name.startsWith(`@now/${desired}@`);
+};
+
+// src/detect-builders.ts
+var import_build_utils2 = require("@vercel/build-utils");
+
+// src/python.ts
+var import_fs = __toESM(require("fs"));
 var import_build_utils = require("@vercel/build-utils");
-var import_python = require("./python");
-var import_buildpack_runtimes = require("./buildpack-runtimes");
-const REGEX_MIDDLEWARE_FILES = "middleware.[jt]s";
-const VERCEL_PLATFORM_FILES = [
+var import_python_analysis = require("@vercel/python-analysis");
+async function isPythonEntrypoint(fsPath) {
+  try {
+    const content = await import_fs.default.promises.readFile(fsPath, "utf-8");
+    return await (0, import_python_analysis.findAppOrHandler)(content) !== null;
+  } catch (err) {
+    (0, import_build_utils.debug)(`Failed to check Python entrypoint: ${err}`);
+    return false;
+  }
+}
+
+// src/buildpack-runtimes.ts
+var BUILDPACK_PROJECT_MARKERS = /* @__PURE__ */ new Map([["ruby", ["Gemfile"]]]);
+function isBuildpackRuntimeEnabled(runtime) {
+  return process.env[`VERCEL_EXPERIMENTAL_BUILDPACK_${runtime.toUpperCase()}`] === "1";
+}
+function toBuildpackRuntime(runtime) {
+  if (!runtime || !BUILDPACK_PROJECT_MARKERS.has(runtime) || !isBuildpackRuntimeEnabled(runtime)) {
+    return void 0;
+  }
+  return runtime;
+}
+
+// src/detect-builders.ts
+var REGEX_MIDDLEWARE_FILES = "middleware.[jt]s";
+var VERCEL_PLATFORM_FILES = [
   "api/**",
   "node_modules/**",
   REGEX_MIDDLEWARE_FILES,
@@ -66,7 +371,7 @@ const VERCEL_PLATFORM_FILES = [
   ".gitignore",
   "README.md"
 ];
-const REGEX_VERCEL_PLATFORM_FILES = VERCEL_PLATFORM_FILES.join(",");
+var REGEX_VERCEL_PLATFORM_FILES = VERCEL_PLATFORM_FILES.join(",");
 function escapeMinimatchPath(path) {
   return path.replace(/([\\,*?[\]{}()!+@])/g, "\\$1");
 }
@@ -76,8 +381,8 @@ function getStaticFilesPattern(additionalExclusions = []) {
     ...additionalExclusions.map(escapeMinimatchPath)
   ].join(",")}}`;
 }
-const REGEX_NON_VERCEL_PLATFORM_FILES = getStaticFilesPattern();
-const builderToFrameworks = (() => {
+var REGEX_NON_VERCEL_PLATFORM_FILES = getStaticFilesPattern();
+var builderToFrameworks = (() => {
   const map = /* @__PURE__ */ new Map();
   for (const f of import_frameworks.frameworkList) {
     if (!f.useRuntime?.use)
@@ -110,7 +415,7 @@ function detectApiDirectory(builders) {
 }
 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) {
+    if (typeof builder.src === "string" && isOfficialRuntime("static", builder.use) && /^.*\/\*\*\/\*$/.test(builder.src) && builder.config?.zeroConfig === true) {
       return builder;
     }
   }
@@ -160,6 +465,13 @@ async function detectBuilders(files, pkg, options = {}) {
       usedFunctions.add(key);
   };
   const absolutePathCache = /* @__PURE__ */ new Map();
+  const proxyFile = options.proxy ? parseProxyEntrypoint(options.proxy.entrypoint).file : null;
+  const reservedFunctionFiles = options.reservedFunctionFiles ?? [];
+  const claimedFiles = /* @__PURE__ */ new Set([
+    ...proxyFile !== null ? [proxyFile] : [],
+    ...reservedFunctionFiles
+  ]);
+  const hasReservedFunctions = reservedFunctionFiles.length > 0;
   const { buildCommand, outputDirectory } = projectSettings;
   const frameworkConfig = import_framework.frameworksBySlug.get(framework || "");
   const rustStaticOutput = isRustStaticOutput(framework, projectSettings);
@@ -186,7 +498,7 @@ async function detectBuilders(files, pkg, options = {}) {
   const apiRoutes = [];
   const dynamicRoutes = [];
   for (const fileName of sortedFiles) {
-    if (fileName === options.proxy?.entrypoint) {
+    if (claimedFiles.has(fileName)) {
       continue;
     }
     const apiBuilder = await maybeGetApiBuilder(fileName, apiMatches, options);
@@ -250,7 +562,7 @@ async function detectBuilders(files, pkg, options = {}) {
       options
     );
   } else {
-    if (pkg && !makeFrontendStatic && !apiBuilders.length && !options.ignoreBuildScript) {
+    if (pkg && !makeFrontendStatic && !apiBuilders.length && !hasReservedFunctions && !options.ignoreBuildScript) {
       errors.push(getMissingBuildScriptError());
       return {
         errors,
@@ -271,19 +583,17 @@ async function detectBuilders(files, pkg, options = {}) {
           outputDirectory: usedOutputDirectory
         }
       };
-    } else if (apiBuilders.length && hasNoneApiFiles) {
+    } else if ((apiBuilders.length || hasReservedFunctions) && hasNoneApiFiles) {
       frontendBuilder = {
         use: "@vercel/static",
-        src: getStaticFilesPattern(
-          options.proxy ? [options.proxy.entrypoint] : []
-        ),
+        src: getStaticFilesPattern([...claimedFiles]),
         config: {
           zeroConfig: true
         }
       };
     }
   }
-  if (options.proxy && frontendBuilder && (0, import_is_official_runtime.isOfficialRuntime)("next", frontendBuilder.use)) {
+  if (options.proxy && frontendBuilder && isOfficialRuntime("next", frontendBuilder.use)) {
     return {
       builders: null,
       errors: [
@@ -302,6 +612,7 @@ async function detectBuilders(files, pkg, options = {}) {
   const unusedFunctionError = checkUnusedFunctions(
     frontendBuilder,
     usedFunctions,
+    claimedFiles,
     options
   );
   if (unusedFunctionError) {
@@ -326,7 +637,7 @@ async function detectBuilders(files, pkg, options = {}) {
     builders.push(...apiBuilders);
   }
   if (frontendBuilder) {
-    if ((0, import_is_official_runtime.isOfficialRuntime)("express", frontendBuilder?.use) || (0, import_is_official_runtime.isOfficialRuntime)("hono", frontendBuilder?.use) || (0, import_is_official_runtime.isOfficialRuntime)("python", frontendBuilder?.use) || (0, import_is_official_runtime.isOfficialRuntime)("go", frontendBuilder?.use) || (0, import_is_official_runtime.isOfficialRuntime)("backends", frontendBuilder?.use)) {
+    if (isOfficialRuntime("express", frontendBuilder?.use) || isOfficialRuntime("hono", frontendBuilder?.use) || isOfficialRuntime("python", frontendBuilder?.use) || isOfficialRuntime("go", frontendBuilder?.use) || isOfficialRuntime("backends", frontendBuilder?.use)) {
       builders.push({
         src: "public/**/*",
         use: "@vercel/static",
@@ -337,7 +648,7 @@ async function detectBuilders(files, pkg, options = {}) {
       });
     }
     builders.push(frontendBuilder);
-    if (hasNextApiFiles && apiBuilders.some((b) => (0, import_is_official_runtime.isOfficialRuntime)("node", b.use))) {
+    if (hasNextApiFiles && apiBuilders.some((b) => isOfficialRuntime("node", b.use))) {
       warnings.push({
         code: "conflicting_files",
         message: "When using Next.js, it is recommended to place JavaScript Functions inside of the `pages/api` (provided by Next.js) directory instead of `api` (provided by Vercel). Other languages (Python, Go, etc) should still go in the `api` directory.",
@@ -386,7 +697,7 @@ async function maybeGetApiBuilder(fileName, apiMatches, options) {
   }
   if (fileName.endsWith(".py") && options.workPath) {
     const fsPath = (0, import_path.join)(options.workPath, fileName);
-    const isEntrypoint = await (0, import_python.isPythonEntrypoint)(fsPath);
+    const isEntrypoint = await isPythonEntrypoint(fsPath);
     if (!isEntrypoint) {
       return null;
     }
@@ -394,7 +705,7 @@ async function maybeGetApiBuilder(fileName, apiMatches, options) {
   const nodeExtensions = [".js", ".mjs", ".ts", ".tsx"];
   if (fileName.startsWith("api/") && process.env.VERCEL_NODE_FILTER_ENTRYPOINTS === "1" && nodeExtensions.some((ext) => fileName.endsWith(ext)) && options.workPath) {
     const fsPath = (0, import_path.join)(options.workPath, fileName);
-    const isEntrypoint = await (0, import_build_utils.isNodeEntrypoint)({ fsPath });
+    const isEntrypoint = await (0, import_build_utils2.isNodeEntrypoint)({ fsPath });
     if (!isEntrypoint) {
       return null;
     }
@@ -438,14 +749,25 @@ function getFunction(fileName, { functions = {} }) {
   const func = keys.find((key) => key === fileName || (0, import_minimatch.default)(fileName, key));
   return func ? { fnPattern: func, func: functions[func] } : { fnPattern: null, func: null };
 }
+function parseProxyEntrypoint(entrypoint) {
+  if (process.env.VERCEL_PYTHON_PROXY) {
+    const parsed = (0, import_entrypoint.parsePyModuleAttrEntrypoint)(entrypoint);
+    if (parsed)
+      return { file: parsed.filePath, variable: parsed.attrName };
+  }
+  return { file: entrypoint };
+}
 function getProxyBuilder(proxy, tag, functions = {}) {
-  const { fnPattern, func } = getFunction(proxy.entrypoint, { functions });
+  const { file, variable } = parseProxyEntrypoint(proxy.entrypoint);
+  const isPython = (0, import_path.extname)(file) === ".py";
+  const { fnPattern, func } = getFunction(file, { functions });
   const runtime = func?.runtime;
   const config = {
     zeroConfig: true,
     middleware: true,
-    ...!runtime ? { middlewareRuntime: "nodejs" } : {},
-    ...proxy.matcher ? { middlewareMatcher: proxy.matcher } : {}
+    ...!runtime && !isPython ? { middlewareRuntime: "nodejs" } : {},
+    ...proxy.matcher ? { middlewareMatcher: proxy.matcher } : {},
+    ...variable ? { handlerFunction: variable } : {}
   };
   if (fnPattern && func) {
     config.functions = { [fnPattern]: func };
@@ -456,9 +778,10 @@ function getProxyBuilder(proxy, tag, functions = {}) {
       config.excludeFiles = func.excludeFiles;
     }
   }
+  const defaultRuntime = isPython ? `@vercel/python${tag ? `@${tag}` : ""}` : `@vercel/node${tag ? `@${tag}` : ""}`;
   return {
-    src: proxy.entrypoint,
-    use: runtime || `@vercel/node${tag ? `@${tag}` : ""}`,
+    src: file,
+    use: runtime || defaultRuntime,
     config
   };
 }
@@ -481,21 +804,29 @@ function validateProxyConfig(proxy) {
   if (typeof proxy !== "object" || typeof proxy.entrypoint !== "string" || !proxy.entrypoint) {
     return {
       code: "invalid_proxy",
-      message: "The `proxy` property must contain an `entrypoint` string that references a `.js` or `.ts` file."
+      message: "The `proxy` property must contain an `entrypoint` string."
     };
   }
-  const entrypoint = proxy.entrypoint;
-  const segments = entrypoint.split("/");
-  if (entrypoint.startsWith("/") || entrypoint.includes("\\") || segments.includes(".") || segments.includes("..") || /[?#\u0000-\u001f]/.test(entrypoint)) {
+  const { file, variable } = parseProxyEntrypoint(proxy.entrypoint);
+  const isPythonForm = (0, import_path.extname)(file) === ".py";
+  const isJsForm = /\.(?:js|ts)$/.test(file) && !file.endsWith(".d.ts");
+  const segments = file.split("/");
+  if (file.startsWith("/") || file.includes("\\") || segments.includes(".") || segments.includes("..") || /[?#\u0000-\u001f]/.test(file)) {
     return {
       code: "invalid_proxy_entrypoint",
       message: "The `proxy.entrypoint` path must be relative to the project root and cannot contain traversal, query, fragment, or control characters."
     };
   }
-  if (!/\.(?:js|ts)$/.test(entrypoint) || entrypoint.endsWith(".d.ts")) {
+  if (!isPythonForm && !isJsForm) {
     return {
       code: "invalid_proxy_entrypoint",
-      message: "The `proxy.entrypoint` path must end in `.js` or `.ts` and reference an executable file."
+      message: "The `proxy.entrypoint` must be a `.js` or `.ts` file path, or a Python `module:attr`."
+    };
+  }
+  if (isPythonForm && !variable) {
+    return {
+      code: "invalid_proxy_entrypoint",
+      message: "Python proxy entrypoints must use `module:attr` syntax, not a plain `.py` path."
     };
   }
   if (proxy.matcher !== void 0) {
@@ -520,10 +851,11 @@ function validateProxy(options, files, framework) {
   if (configError) {
     return configError;
   }
-  if (!files.includes(proxy.entrypoint)) {
+  const { file } = parseProxyEntrypoint(proxy.entrypoint);
+  if (!files.includes(file)) {
     return {
       code: "proxy_entrypoint_not_found",
-      message: `The proxy entrypoint \`${proxy.entrypoint}\` does not exist. Set \`proxy.entrypoint\` to an existing \`.js\` or \`.ts\` file.`
+      message: `The proxy entrypoint \`${proxy.entrypoint}\` does not exist.`
     };
   }
   if (framework === "nextjs" || framework === "astro") {
@@ -533,7 +865,8 @@ function validateProxy(options, files, framework) {
     };
   }
   const appRuntime = (0, import_framework.inferBuilderRuntimeFromFramework)(framework);
-  const proxyRuntime = import_constants.ENTRYPOINT_EXTENSIONS[(0, import_path.extname)(proxy.entrypoint)];
+  const { file: proxyFile } = parseProxyEntrypoint(proxy.entrypoint);
+  const proxyRuntime = import_constants.ENTRYPOINT_EXTENSIONS[(0, import_path.extname)(proxyFile)];
   if (appRuntime !== void 0 && proxyRuntime !== void 0 && appRuntime !== proxyRuntime) {
     return {
       code: "proxy_runtime_mismatch",
@@ -596,8 +929,8 @@ function detectFrontBuilder(pkg, files, usedFunctions, fallbackEntrypoint, optio
   }
   const f = import_framework.frameworksBySlug.get(framework || "");
   if (f && f.useRuntime && !isRustStaticOutput(framework, projectSettings)) {
-    const buildpackRuntime = (0, import_buildpack_runtimes.toBuildpackRuntime)(framework);
-    if (buildpackRuntime && (import_buildpack_runtimes.BUILDPACK_PROJECT_MARKERS.get(buildpackRuntime) ?? []).some(
+    const buildpackRuntime = toBuildpackRuntime(framework);
+    if (buildpackRuntime && (BUILDPACK_PROJECT_MARKERS.get(buildpackRuntime) ?? []).some(
       (marker) => files.includes(marker)
     )) {
       config.buildpack = buildpackRuntime;
@@ -608,8 +941,8 @@ function detectFrontBuilder(pkg, files, usedFunctions, fallbackEntrypoint, optio
       };
     }
     const { src, use } = f.useRuntime;
-    const shouldUseUnifiedBackend = (0, import_build_utils.isExperimentalBackendsEnabled)() && import_build_utils.BACKEND_BUILDERS.includes(use);
-    const finalUse = shouldUseUnifiedBackend ? import_build_utils.UNIFIED_BACKEND_BUILDER : use;
+    const shouldUseUnifiedBackend = (0, import_build_utils2.isExperimentalBackendsEnabled)() && import_build_utils2.BACKEND_BUILDERS.includes(use);
+    const finalUse = shouldUseUnifiedBackend ? import_build_utils2.UNIFIED_BACKEND_BUILDER : use;
     return { src, use: `${finalUse}${withTag}`, config };
   }
   const entrypoints = /* @__PURE__ */ new Set([
@@ -654,7 +987,7 @@ function validateFunctions({ functions = {} }) {
         message: "Function must contain at least one property."
       };
     }
-    const maxDurationLimit = (0, import_build_utils.getMaxDurationLimit)();
+    const maxDurationLimit = (0, import_build_utils2.getMaxDurationLimit)();
     if (func.maxDuration !== void 0 && func.maxDuration !== "max" && (func.maxDuration < 1 || maxDurationLimit !== void 0 && func.maxDuration > maxDurationLimit || !Number.isInteger(func.maxDuration))) {
       return {
         code: "invalid_function_duration",
@@ -701,14 +1034,22 @@ function validateFunctions({ functions = {} }) {
   }
   return null;
 }
-function checkUnusedFunctions(frontendBuilder, usedFunctions, options) {
+function checkUnusedFunctions(frontendBuilder, usedFunctions, claimedFiles, options) {
   const unusedFunctions = new Set(
     Object.keys(options.functions || {}).filter((key) => !usedFunctions.has(key))
   );
+  for (const fnKey of unusedFunctions) {
+    for (const filePath of claimedFiles) {
+      if (filePath === fnKey || (0, import_minimatch.default)(filePath, fnKey)) {
+        unusedFunctions.delete(fnKey);
+        break;
+      }
+    }
+  }
   if (!unusedFunctions.size) {
     return null;
   }
-  if (frontendBuilder && (0, import_is_official_runtime.isOfficialRuntime)("next", frontendBuilder.use)) {
+  if (frontendBuilder && isOfficialRuntime("next", frontendBuilder.use)) {
     for (const fnKey of unusedFunctions.values()) {
       if (fnKey.startsWith("pages/") || fnKey.startsWith("src/pages") || fnKey.startsWith("app/") || fnKey.startsWith("src/app/") || fnKey.startsWith("middleware") || fnKey.startsWith("src/middleware")) {
         unusedFunctions.delete(fnKey);
@@ -722,7 +1063,7 @@ function checkUnusedFunctions(frontendBuilder, usedFunctions, options) {
       }
     }
   }
-  if (frontendBuilder && ((0, import_is_official_runtime.isOfficialRuntime)("express", frontendBuilder.use) || (0, import_is_official_runtime.isOfficialRuntime)("hono", frontendBuilder.use) || (0, import_is_official_runtime.isOfficialRuntime)("python", frontendBuilder.use) || (0, import_is_official_runtime.isOfficialRuntime)("backends", frontendBuilder.use))) {
+  if (frontendBuilder && (isOfficialRuntime("express", frontendBuilder.use) || isOfficialRuntime("hono", frontendBuilder.use) || isOfficialRuntime("python", frontendBuilder.use) || isOfficialRuntime("backends", frontendBuilder.use))) {
     return null;
   }
   if (unusedFunctions.size) {
@@ -912,7 +1253,7 @@ function getRouteResult(apiRoutes, dynamicRoutes, outputDirectory, apiBuilders,
   const errorRoutes = [];
   const framework = frontendBuilder?.config?.framework || "";
   const isGatsby = framework === "gatsby";
-  const isNextjs = framework === "nextjs" || (0, import_is_official_runtime.isOfficialRuntime)("next", frontendBuilder?.use);
+  const isNextjs = framework === "nextjs" || isOfficialRuntime("next", frontendBuilder?.use);
   const ignoreRuntimes = import_framework.frameworksBySlug.get(framework)?.ignoreRuntimes;
   if (apiRoutes && apiRoutes.length > 0) {
     if (options.featHandleMiss) {
@@ -961,7 +1302,7 @@ function getRouteResult(apiRoutes, dynamicRoutes, outputDirectory, apiBuilders,
       }
     }
   }
-  if (outputDirectory && frontendBuilder && !options.featHandleMiss && (0, import_is_official_runtime.isOfficialRuntime)("static", frontendBuilder.use)) {
+  if (outputDirectory && frontendBuilder && !options.featHandleMiss && isOfficialRuntime("static", frontendBuilder.use)) {
     defaultRoutes.push({
       src: "/(.*)",
       dest: `/${outputDirectory}/$1`

package/dist/services/resolve-v2.js

@@ -248,7 +248,7 @@ async function resolveConfiguredServiceV2(name, config, fs) {
       }
     };
   }
-  const buildpackRuntime = flaggedBuildpackRuntime && !entrypointFile && !(0, import_framework.isFrontendFramework)(framework) && await (0, import_buildpack_runtimes.hasBuildpackProjectMarker)(
+  const buildpackRuntime = flaggedBuildpackRuntime && (!entrypointFile || flaggedBuildpackRuntime === "ruby" && entrypointFile === "config.ru") && !(0, import_framework.isFrontendFramework)(framework) && await (0, import_buildpack_runtimes.hasBuildpackProjectMarker)(
     flaggedBuildpackRuntime,
     (marker) => (0, import_utils.hasFile)(serviceFs, marker)
   ) ? flaggedBuildpackRuntime : void 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/fs-detectors",
-  "version": "7.6.1",
+  "version": "7.7.0",
   "description": "Vercel filesystem detectors",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,11 +20,11 @@
     "minimatch": "3.1.2",
     "semver": "6.3.1",
     "smol-toml": "1.5.2",
-    "@vercel/build-utils": "14.10.2",
+    "@vercel/error-utils": "2.2.1",
+    "@vercel/build-utils": "14.11.0",
     "@vercel/frameworks": "3.34.0",
-    "@vercel/python-analysis": "0.14.0",
     "@vercel/routing-utils": "6.6.0",
-    "@vercel/error-utils": "2.2.1"
+    "@vercel/python-analysis": "0.14.0"
   },
   "devDependencies": {
     "@types/glob": "7.2.0",
@@ -33,10 +33,10 @@
     "@types/node": "20.11.0",
     "@types/semver": "7.3.10",
     "vitest": "4.1.10",
-    "@vercel-internals/runtimes": "1.1.1"
+    "@vercel-internals/runtimes": "1.1.2"
   },
   "scripts": {
-    "build": "node ../../utils/build.mjs",
+    "build": "node build.mjs",
     "test": "vitest run --config ../../vitest.config.mts",
     "test-unit": "vitest run --config ../../vitest.config.mts test/unit.",
     "type-check": "tsc --noEmit"