@vercel/python 6.9.0 → 6.11.0

package/dist/index.js

@@ -137,12 +137,12 @@ var require_isexe = __commonJS({
         if (typeof Promise !== "function") {
           throw new TypeError("callback not provided");
         }
-        return new Promise(function(resolve2, reject) {
+        return new Promise(function(resolve, reject) {
           isexe(path, options || {}, function(er, is) {
             if (er) {
               reject(er);
             } else {
-              resolve2(is);
+              resolve(is);
             }
           });
         });
@@ -1498,7 +1498,7 @@ var require_parse = __commonJS({
     var escape = require_escape();
     var readShebang = require_readShebang();
     var semver = require_semver();
-    var isWin4 = process.platform === "win32";
+    var isWin3 = process.platform === "win32";
     var isExecutableRegExp = /\.(?:com|exe)$/i;
     var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
     var supportsShellOption = niceTry(() => semver.satisfies(process.version, "^4.8.0 || ^5.7.0 || >= 6.0.0", true)) || false;
@@ -1513,7 +1513,7 @@ var require_parse = __commonJS({
       return parsed.file;
     }
     function parseNonShell(parsed) {
-      if (!isWin4) {
+      if (!isWin3) {
         return parsed;
       }
       const commandFile = detectShebang(parsed);
@@ -1535,7 +1535,7 @@ var require_parse = __commonJS({
         return parsed;
       }
       const shellCommand = [parsed.command].concat(parsed.args).join(" ");
-      if (isWin4) {
+      if (isWin3) {
         parsed.command = typeof parsed.options.shell === "string" ? parsed.options.shell : process.env.comspec || "cmd.exe";
         parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
         parsed.options.windowsVerbatimArguments = true;
@@ -1578,7 +1578,7 @@ var require_parse = __commonJS({
 var require_enoent = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@6.0.5/node_modules/cross-spawn/lib/enoent.js"(exports, module2) {
     "use strict";
-    var isWin4 = process.platform === "win32";
+    var isWin3 = process.platform === "win32";
     function notFoundError(original, syscall) {
       return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
         code: "ENOENT",
@@ -1589,7 +1589,7 @@ var require_enoent = __commonJS({
       });
     }
     function hookChildProcess(cp, parsed) {
-      if (!isWin4) {
+      if (!isWin3) {
         return;
       }
       const originalEmit = cp.emit;
@@ -1604,13 +1604,13 @@ var require_enoent = __commonJS({
       };
     }
     function verifyENOENT(status, parsed) {
-      if (isWin4 && status === 1 && !parsed.file) {
+      if (isWin3 && status === 1 && !parsed.file) {
         return notFoundError(parsed.original, "spawn");
       }
       return null;
     }
     function verifyENOENTSync(status, parsed) {
-      if (isWin4 && status === 1 && !parsed.file) {
+      if (isWin3 && status === 1 && !parsed.file) {
         return notFoundError(parsed.original, "spawnSync");
       }
       return null;
@@ -2042,7 +2042,7 @@ var require_get_stream = __commonJS({
       options = Object.assign({ maxBuffer: Infinity }, options);
       const { maxBuffer } = options;
       let stream;
-      return new Promise((resolve2, reject) => {
+      return new Promise((resolve, reject) => {
         const rejectPromise = (error) => {
           if (error) {
             error.bufferedData = stream.getBufferedValue();
@@ -2054,7 +2054,7 @@ var require_get_stream = __commonJS({
             rejectPromise(error);
             return;
           }
-          resolve2();
+          resolve();
         });
         stream.on("data", () => {
           if (stream.getBufferedLength() > maxBuffer) {
@@ -2078,11 +2078,11 @@ var require_p_finally = __commonJS({
       onFinally = onFinally || (() => {
       });
       return promise.then(
-        (val) => new Promise((resolve2) => {
-          resolve2(onFinally());
+        (val) => new Promise((resolve) => {
+          resolve(onFinally());
         }).then(() => val),
-        (err) => new Promise((resolve2) => {
-          resolve2(onFinally());
+        (err) => new Promise((resolve) => {
+          resolve(onFinally());
         }).then(() => {
           throw err;
         })
@@ -2143,7 +2143,7 @@ var require_signal_exit = __commonJS({
     } else {
       assert = require("assert");
       signals = require_signals();
-      isWin4 = /^win/i.test(process2.platform);
+      isWin3 = /^win/i.test(process2.platform);
       EE = require("events");
       if (typeof EE !== "function") {
         EE = EE.EventEmitter;
@@ -2215,7 +2215,7 @@ var require_signal_exit = __commonJS({
             unload();
             emit("exit", null, sig);
             emit("afterexit", null, sig);
-            if (isWin4 && sig === "SIGHUP") {
+            if (isWin3 && sig === "SIGHUP") {
               sig = "SIGINT";
             }
             process2.kill(process2.pid, sig);
@@ -2272,7 +2272,7 @@ var require_signal_exit = __commonJS({
     }
     var assert;
     var signals;
-    var isWin4;
+    var isWin3;
     var EE;
     var emitter;
     var unload;
@@ -2461,8 +2461,8 @@ var require_execa = __commonJS({
       }
       let ret;
       if (!buffer) {
-        ret = new Promise((resolve2, reject) => {
-          process2[stream].once("end", resolve2).once("error", reject);
+        ret = new Promise((resolve, reject) => {
+          process2[stream].once("end", resolve).once("error", reject);
         });
       } else if (encoding) {
         ret = _getStream(process2[stream], {
@@ -2551,19 +2551,19 @@ ${stderr}${stdout}`;
           spawned.kill(parsed.opts.killSignal);
         }, parsed.opts.timeout);
       }
-      const processDone = new Promise((resolve2) => {
+      const processDone = new Promise((resolve) => {
         spawned.on("exit", (code, signal) => {
           cleanup();
-          resolve2({ code, signal });
+          resolve({ code, signal });
         });
         spawned.on("error", (err) => {
           cleanup();
-          resolve2({ error: err });
+          resolve({ error: err });
         });
         if (spawned.stdin) {
           spawned.stdin.on("error", (err) => {
             cleanup();
-            resolve2({ error: err });
+            resolve({ error: err });
           });
         }
       });
@@ -2651,7 +2651,7 @@ ${stderr}${stdout}`;
 var require_lib = __commonJS({
   "../../node_modules/.pnpm/which@3.0.0/node_modules/which/lib/index.js"(exports, module2) {
     var isexe = require_isexe();
-    var { join: join7, delimiter, sep, posix } = require("path");
+    var { join: join7, delimiter: delimiter2, sep, posix } = require("path");
     var isWindows = process.platform === "win32";
     var rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? "" : sep}]`.replace(/(\\)/g, "\\$1"));
     var rRel = new RegExp(`^\\.${rSlash.source}`);
@@ -2659,7 +2659,7 @@ var require_lib = __commonJS({
     var getPathInfo = (cmd, {
       path: optPath = process.env.PATH,
       pathExt: optPathExt = process.env.PATHEXT,
-      delimiter: optDelimiter = delimiter
+      delimiter: optDelimiter = delimiter2
     }) => {
       const pathEnv = cmd.match(rSlash) ? [""] : [
         // windows always checks the cwd first
@@ -2761,9 +2761,9 @@ var import_build_utils8 = require("@vercel/build-utils");
 // src/install.ts
 var import_execa3 = __toESM(require_execa());
 var import_fs3 = __toESM(require("fs"));
-var import_os2 = __toESM(require("os"));
 var import_path4 = require("path");
 var import_build_utils4 = require("@vercel/build-utils");
+var import_python_analysis = require("@vercel/python-analysis");
 
 // src/utils.ts
 var import_fs2 = __toESM(require("fs"));
@@ -3061,7 +3061,8 @@ function createVenvEnv(venvPath, baseEnv = process.env) {
 }
 async function ensureVenv({
   pythonPath,
-  venvPath
+  venvPath,
+  uvPath
 }) {
   const marker = (0, import_path3.join)(venvPath, "pyvenv.cfg");
   try {
@@ -3071,7 +3072,11 @@ async function ensureVenv({
   }
   await import_fs2.default.promises.mkdir(venvPath, { recursive: true });
   console.log(`Creating virtual environment at "${venvPath}"...`);
-  await (0, import_execa2.default)(pythonPath, ["-m", "venv", venvPath]);
+  if (uvPath) {
+    await (0, import_execa2.default)(uvPath, ["venv", venvPath]);
+  } else {
+    await (0, import_execa2.default)(pythonPath, ["-m", "venv", venvPath]);
+  }
 }
 function getVenvPythonBin(venvPath) {
   return (0, import_path3.join)(getVenvBinDir(venvPath), isWin2 ? "python.exe" : "python");
@@ -3379,7 +3384,6 @@ function isInstalled({ version: version2 }) {
 }
 
 // src/install.ts
-var isWin3 = process.platform === "win32";
 var makeDependencyCheckCode = (dependency) => `
 from importlib import util
 dep = '${dependency}'.replace('-', '_')
@@ -3455,225 +3459,130 @@ function resolveVendorDir() {
   const vendorDir = process.env.VERCEL_PYTHON_VENDOR_DIR || "_vendor";
   return vendorDir;
 }
+function toBuildError(error) {
+  return new import_build_utils4.NowBuildError({
+    code: error.code,
+    message: error.message,
+    link: error.link,
+    action: error.action
+  });
+}
 async function detectInstallSource({
   workPath,
   entryDirectory,
-  fsFiles
+  repoRootPath
 }) {
-  const uvLockDir = findDir({
-    file: "uv.lock",
-    entryDirectory,
-    workPath,
-    fsFiles
-  });
-  const pyprojectDir = findDir({
-    file: "pyproject.toml",
-    entryDirectory,
-    workPath,
-    fsFiles
-  });
-  const pipfileLockDir = findDir({
-    file: "Pipfile.lock",
-    entryDirectory,
-    workPath,
-    fsFiles
-  });
-  const pipfileDir = findDir({
-    file: "Pipfile",
-    entryDirectory,
-    workPath,
-    fsFiles
-  });
-  const requirementsDir = findDir({
-    file: "requirements.txt",
-    entryDirectory,
-    workPath,
-    fsFiles
-  });
-  let manifestPath = null;
-  let manifestType = null;
-  if (uvLockDir && pyprojectDir) {
-    manifestType = "uv.lock";
-    manifestPath = (0, import_path4.join)(uvLockDir, "uv.lock");
-  } else if (pyprojectDir) {
-    manifestType = "pyproject.toml";
-    manifestPath = (0, import_path4.join)(pyprojectDir, "pyproject.toml");
-  } else if (pipfileLockDir) {
-    manifestType = "Pipfile.lock";
-    manifestPath = (0, import_path4.join)(pipfileLockDir, "Pipfile.lock");
-  } else if (pipfileDir) {
-    manifestType = "Pipfile";
-    manifestPath = (0, import_path4.join)(pipfileDir, "Pipfile");
-  } else if (requirementsDir) {
-    manifestType = "requirements.txt";
-    manifestPath = (0, import_path4.join)(requirementsDir, "requirements.txt");
-  }
-  let manifestContent;
-  if (manifestPath) {
-    try {
-      manifestContent = await import_fs3.default.promises.readFile(manifestPath, "utf8");
-    } catch (err) {
-      (0, import_build_utils4.debug)("Failed to read install manifest contents", err);
+  const entrypointDir = (0, import_path4.join)(workPath, entryDirectory);
+  const rootDir = repoRootPath ?? workPath;
+  let pythonPackage;
+  try {
+    pythonPackage = await (0, import_python_analysis.discoverPythonPackage)({
+      entrypointDir,
+      rootDir
+    });
+  } catch (error) {
+    if (error instanceof import_python_analysis.PythonAnalysisError) {
+      throw toBuildError(error);
     }
+    throw error;
   }
-  return { manifestPath, manifestType, manifestContent };
-}
-async function createPyprojectToml({
-  projectName,
-  pyprojectPath,
-  dependencies,
-  pythonVersion
-}) {
-  const version2 = pythonVersion ?? DEFAULT_PYTHON_VERSION;
-  const requiresPython = `~=${version2}.0`;
-  const depsToml = dependencies.length > 0 ? [
-    "dependencies = [",
-    ...dependencies.map((dep) => `  "${dep}",`),
-    "]"
-  ].join("\n") : "dependencies = []";
-  const content = [
-    "[project]",
-    `name = "${projectName}"`,
-    'version = "0.1.0"',
-    `requires-python = "${requiresPython}"`,
-    "classifiers = [",
-    '  "Private :: Do Not Upload",',
-    "]",
-    depsToml,
-    ""
-  ].join("\n");
-  await import_fs3.default.promises.writeFile(pyprojectPath, content);
-}
-function findUvLockUpwards(startDir, repoRootPath) {
-  const start = (0, import_path4.resolve)(startDir);
-  const base = repoRootPath ? (0, import_path4.resolve)(repoRootPath) : void 0;
-  for (const dir of (0, import_build_utils4.traverseUpDirectories)({ start, base })) {
-    const lockPath = (0, import_path4.join)(dir, "uv.lock");
-    const pyprojectPath = (0, import_path4.join)(dir, "pyproject.toml");
-    if (import_fs3.default.existsSync(lockPath) && import_fs3.default.existsSync(pyprojectPath)) {
-      return lockPath;
-    }
+  let manifestType = null;
+  let manifestPath = null;
+  const lockFile = pythonPackage.manifest?.lockFile ?? pythonPackage.workspaceLockFile;
+  if (lockFile) {
+    if (lockFile.kind === import_python_analysis.PythonLockFileKind.UvLock) {
+      manifestType = "uv.lock";
+      manifestPath = (0, import_path4.join)(rootDir, lockFile.path);
+    } else if (lockFile.kind === import_python_analysis.PythonLockFileKind.PylockToml) {
+      manifestType = "pylock.toml";
+      manifestPath = (0, import_path4.join)(rootDir, lockFile.path);
+    }
+  } else if (pythonPackage.manifest) {
+    manifestType = "pyproject.toml";
+    manifestPath = (0, import_path4.join)(rootDir, pythonPackage.manifest.path);
   }
-  return null;
+  return { manifestPath, manifestType, pythonPackage };
 }
 async function ensureUvProject({
   workPath,
   entryDirectory,
-  fsFiles,
   repoRootPath,
-  pythonPath,
-  pipPath,
   pythonVersion,
-  uv,
-  venvPath,
-  meta
+  uv
 }) {
-  const uvPath = uv.getPath();
+  const rootDir = repoRootPath ?? workPath;
   const installInfo = await detectInstallSource({
     workPath,
     entryDirectory,
-    fsFiles
+    repoRootPath
   });
-  const { manifestType, manifestPath } = installInfo;
+  const { manifestType, pythonPackage } = installInfo;
+  const manifest = pythonPackage?.manifest;
   let projectDir;
   let pyprojectPath;
   let lockPath = null;
-  if (manifestType === "uv.lock") {
-    if (!manifestPath) {
-      throw new Error("Expected uv.lock path to be resolved, but it was null");
+  if (manifestType === "uv.lock" || manifestType === "pylock.toml") {
+    const lockFile = pythonPackage?.manifest?.lockFile ?? pythonPackage?.workspaceLockFile;
+    if (!lockFile) {
+      throw new Error(
+        `Expected lock file path to be resolved, but it was null`
+      );
     }
-    projectDir = (0, import_path4.dirname)(manifestPath);
+    lockPath = (0, import_path4.join)(rootDir, lockFile.path);
+    projectDir = (0, import_path4.dirname)(lockPath);
     pyprojectPath = (0, import_path4.join)(projectDir, "pyproject.toml");
     if (!import_fs3.default.existsSync(pyprojectPath)) {
       throw new Error(
-        `Expected "pyproject.toml" next to "uv.lock" in "${projectDir}"`
+        `Expected "pyproject.toml" next to "${lockFile.kind}" in "${projectDir}"`
       );
     }
-    lockPath = manifestPath;
-    console.log("Installing required dependencies from uv.lock...");
-  } else if (manifestType === "pyproject.toml") {
-    if (!manifestPath) {
-      throw new Error(
-        "Expected pyproject.toml path to be resolved, but it was null"
+    console.log(`Installing required dependencies from ${lockFile.kind}...`);
+  } else if (manifest) {
+    projectDir = (0, import_path4.join)(rootDir, (0, import_path4.dirname)(manifest.path));
+    pyprojectPath = (0, import_path4.join)(rootDir, manifest.path);
+    const originKind = manifest.origin?.kind;
+    if (originKind === import_python_analysis.PythonManifestConvertedKind.Pipfile) {
+      console.log("Installing required dependencies from Pipfile...");
+    } else if (originKind === import_python_analysis.PythonManifestConvertedKind.PipfileLock) {
+      console.log("Installing required dependencies from Pipfile.lock...");
+    } else if (originKind === import_python_analysis.PythonManifestConvertedKind.RequirementsTxt || originKind === import_python_analysis.PythonManifestConvertedKind.RequirementsIn) {
+      console.log(
+        `Installing required dependencies from ${manifest.origin?.path ?? "requirements.txt"}...`
       );
-    }
-    projectDir = (0, import_path4.dirname)(manifestPath);
-    pyprojectPath = manifestPath;
-    console.log("Installing required dependencies from pyproject.toml...");
-    const workspaceLock = findUvLockUpwards(projectDir, repoRootPath);
-    if (workspaceLock) {
-      lockPath = workspaceLock;
     } else {
-      await uv.lock(projectDir);
+      console.log("Installing required dependencies from pyproject.toml...");
     }
-  } else if (manifestType === "Pipfile.lock" || manifestType === "Pipfile") {
-    if (!manifestPath) {
-      throw new Error(
-        "Expected Pipfile/Pipfile.lock path to be resolved, but it was null"
-      );
-    }
-    projectDir = (0, import_path4.dirname)(manifestPath);
-    console.log(`Installing required dependencies from ${manifestType}...`);
-    const exportedReq = await exportRequirementsFromPipfile({
-      pythonPath,
-      pipPath,
-      uvPath,
-      projectDir,
-      meta
-    });
-    pyprojectPath = (0, import_path4.join)(projectDir, "pyproject.toml");
-    if (!import_fs3.default.existsSync(pyprojectPath)) {
-      await createPyprojectToml({
-        projectName: "app",
-        pyprojectPath,
-        dependencies: [],
-        pythonVersion
-      });
-    }
-    await uv.addFromFile({
-      venvPath,
-      projectDir,
-      requirementsPath: exportedReq
-    });
-  } else if (manifestType === "requirements.txt") {
-    if (!manifestPath) {
-      throw new Error(
-        "Expected requirements.txt path to be resolved, but it was null"
-      );
+    if (manifest.origin) {
+      if (manifest.data.project && !manifest.data.project["requires-python"]) {
+        manifest.data.project["requires-python"] = `~=${pythonVersion}.0`;
+      }
+      const content = (0, import_python_analysis.stringifyManifest)(manifest.data);
+      pyprojectPath = (0, import_path4.join)(projectDir, "pyproject.toml");
+      await import_fs3.default.promises.writeFile(pyprojectPath, content);
     }
-    projectDir = (0, import_path4.dirname)(manifestPath);
-    pyprojectPath = (0, import_path4.join)(projectDir, "pyproject.toml");
-    console.log(
-      "Installing required dependencies from requirements.txt with uv..."
-    );
-    if (!import_fs3.default.existsSync(pyprojectPath)) {
-      await createPyprojectToml({
-        projectName: "app",
-        pyprojectPath,
-        dependencies: [],
-        pythonVersion
-      });
+    const workspaceLockFile = pythonPackage?.workspaceLockFile;
+    if (workspaceLockFile) {
+      lockPath = (0, import_path4.join)(rootDir, workspaceLockFile.path);
+    } else {
+      await uv.lock(projectDir);
     }
-    await uv.addFromFile({
-      venvPath,
-      projectDir,
-      requirementsPath: manifestPath
-    });
   } else {
     projectDir = workPath;
     pyprojectPath = (0, import_path4.join)(projectDir, "pyproject.toml");
     console.log(
       "No Python manifest found; creating an empty pyproject.toml and uv.lock..."
     );
-    await createPyprojectToml({
-      projectName: "app",
-      pyprojectPath,
-      dependencies: [],
-      pythonVersion
+    const requiresPython = `~=${pythonVersion}.0`;
+    const minimalManifest = (0, import_python_analysis.createMinimalManifest)({
+      name: "app",
+      requiresPython,
+      dependencies: []
     });
+    const content = (0, import_python_analysis.stringifyManifest)(minimalManifest);
+    await import_fs3.default.promises.writeFile(pyprojectPath, content);
     await uv.lock(projectDir);
   }
-  const resolvedLockPath = lockPath && import_fs3.default.existsSync(lockPath) ? lockPath : findUvLockUpwards(projectDir, repoRootPath) || (0, import_path4.join)(projectDir, "uv.lock");
+  const resolvedLockPath = lockPath && import_fs3.default.existsSync(lockPath) ? lockPath : (0, import_path4.join)(projectDir, "uv.lock");
   return { projectDir, pyprojectPath, lockPath: resolvedLockPath };
 }
 async function pipInstall(pipPath, uvPath, workPath, args, targetDir) {
@@ -3767,46 +3676,6 @@ async function installRequirementsFile({
     targetDir
   );
 }
-async function exportRequirementsFromPipfile({
-  pythonPath,
-  pipPath,
-  uvPath,
-  projectDir,
-  meta
-}) {
-  const tempDir = await import_fs3.default.promises.mkdtemp(
-    (0, import_path4.join)(import_os2.default.tmpdir(), "vercel-pipenv-")
-  );
-  await installRequirement({
-    pythonPath,
-    pipPath,
-    dependency: "pipfile-requirements",
-    version: "0.3.0",
-    workPath: tempDir,
-    meta,
-    args: ["--no-warn-script-location"],
-    uvPath
-  });
-  const tempVendorDir = (0, import_path4.join)(tempDir, resolveVendorDir());
-  const convertCmd = isWin3 ? (0, import_path4.join)(tempVendorDir, "Scripts", "pipfile2req.exe") : (0, import_path4.join)(tempVendorDir, "bin", "pipfile2req");
-  (0, import_build_utils4.debug)(`Running "${convertCmd}" in ${projectDir}...`);
-  let stdout;
-  try {
-    const { stdout: out } = await (0, import_execa3.default)(convertCmd, [], {
-      cwd: projectDir,
-      env: { ...process.env, PYTHONPATH: tempVendorDir }
-    });
-    stdout = out;
-  } catch (err) {
-    throw new Error(
-      `Failed to run "${convertCmd}": ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  const outPath = (0, import_path4.join)(tempDir, "requirements.pipenv.txt");
-  await import_fs3.default.promises.writeFile(outPath, stdout);
-  (0, import_build_utils4.debug)(`Exported pipfile requirements to ${outPath}`);
-  return outPath;
-}
 async function mirrorSitePackagesIntoVendor({
   venvPath,
   vendorDirName
@@ -4044,6 +3913,21 @@ function createDevWsgiShim(workPath, modulePath) {
     return null;
   }
 }
+async function getMultiServicePythonRunner(workPath, env, systemPython, uvPath) {
+  const { pythonCmd, venvRoot } = useVirtualEnv(workPath, env, systemPython);
+  if (venvRoot) {
+    (0, import_build_utils7.debug)(`Using existing virtualenv at ${venvRoot} for multi-service dev`);
+    return { command: pythonCmd, args: [] };
+  }
+  const venvPath = (0, import_path6.join)(workPath, ".venv");
+  await ensureVenv({ pythonPath: systemPython, venvPath, uvPath });
+  (0, import_build_utils7.debug)(`Created virtualenv at ${venvPath} for multi-service dev`);
+  const pythonBin = getVenvPythonBin(venvPath);
+  const binDir = getVenvBinDir(venvPath);
+  env.VIRTUAL_ENV = venvPath;
+  env.PATH = `${binDir}${import_path6.delimiter}${env.PATH || ""}`;
+  return { command: pythonBin, args: [] };
+}
 var startDevServer = async (opts) => {
   const {
     entrypoint: rawEntrypoint,
@@ -4104,44 +3988,70 @@ var startDevServer = async (opts) => {
   let resolveChildReady;
   let rejectChildReady;
   const childReady = new Promise(
-    (resolve2, reject) => {
-      resolveChildReady = resolve2;
+    (resolve, reject) => {
+      resolveChildReady = resolve;
       rejectChildReady = reject;
     }
   );
   PENDING_STARTS.set(serverKey, childReady);
   try {
-    await new Promise((resolve2, reject) => {
-      let resolved = false;
-      const { pythonPath: systemPython } = getDefaultPythonVersion(meta);
-      let pythonCmd = systemPython;
-      const venv = isInVirtualEnv();
-      if (venv) {
-        (0, import_build_utils7.debug)(`Running in virtualenv at ${venv}`);
+    const { pythonPath: systemPython } = getDefaultPythonVersion(meta);
+    const uvPath = await findUvBinary(systemPython);
+    const venv = isInVirtualEnv();
+    const serviceCount = meta.serviceCount ?? 0;
+    const pythonServiceCount = meta.pythonServiceCount ?? 1;
+    if (venv && pythonServiceCount > 1) {
+      const yellow = "\x1B[33m";
+      const white = "\x1B[1m";
+      const reset = "\x1B[0m";
+      throw new import_build_utils7.NowBuildError({
+        code: "PYTHON_EXTERNAL_VENV_DETECTED",
+        message: `Detected activated venv at ${yellow}${venv}${reset}, ${white}vercel dev${reset} manages virtual environments automatically.
+Run ${white}deactivate${reset} and try again.`
+      });
+    }
+    let spawnCommand = systemPython;
+    let spawnArgsPrefix = [];
+    if (serviceCount > 0) {
+      const runner = await getMultiServicePythonRunner(
+        workPath,
+        env,
+        systemPython,
+        uvPath
+      );
+      spawnCommand = runner.command;
+      spawnArgsPrefix = runner.args;
+      (0, import_build_utils7.debug)(
+        `Multi-service Python runner: ${spawnCommand} ${spawnArgsPrefix.join(" ")}`
+      );
+    } else if (venv) {
+      (0, import_build_utils7.debug)(`Running in virtualenv at ${venv}`);
+    } else {
+      const { pythonCmd: venvPythonCmd, venvRoot } = useVirtualEnv(
+        workPath,
+        env,
+        systemPython
+      );
+      spawnCommand = venvPythonCmd;
+      if (venvRoot) {
+        (0, import_build_utils7.debug)(`Using virtualenv at ${venvRoot}`);
       } else {
-        const { pythonCmd: venvPythonCmd, venvRoot } = useVirtualEnv(
-          workPath,
-          env,
-          systemPython
-        );
-        pythonCmd = venvPythonCmd;
-        if (venvRoot) {
-          (0, import_build_utils7.debug)(`Using virtualenv at ${venvRoot}`);
-        } else {
-          (0, import_build_utils7.debug)("No virtualenv found");
-          try {
-            const yellow = "\x1B[33m";
-            const reset = "\x1B[0m";
-            const venvCmd = process.platform === "win32" ? "python -m venv .venv && .venv\\Scripts\\activate" : "python -m venv .venv && source .venv/bin/activate";
-            process.stderr.write(
-              `${yellow}Warning: no virtual environment detected in ${workPath}. Using system Python: ${pythonCmd}.${reset}
+        (0, import_build_utils7.debug)("No virtualenv found");
+        try {
+          const yellow = "\x1B[33m";
+          const reset = "\x1B[0m";
+          const venvCmd = process.platform === "win32" ? "python -m venv .venv && .venv\\Scripts\\activate" : "python -m venv .venv && source .venv/bin/activate";
+          process.stderr.write(
+            `${yellow}Warning: no virtual environment detected in ${workPath}. Using system Python: ${systemPython}.${reset}
 If you are using a virtual environment, activate it before running "vercel dev", or create one: ${venvCmd}
 `
-            );
-          } catch (_) {
-          }
+          );
+        } catch (_) {
         }
       }
+    }
+    await new Promise((resolve, reject) => {
+      let resolved = false;
       if (framework !== "flask") {
         const devShimModule = createDevAsgiShim(workPath, modulePath);
         if (devShimModule) {
@@ -4150,11 +4060,12 @@ If you are using a virtual environment, activate it before running "vercel dev",
           env.PYTHONPATH = existingPythonPath ? `${vercelPythonDir}:${existingPythonPath}` : vercelPythonDir;
         }
         const moduleToRun = devShimModule || modulePath;
-        const argv = ["-u", "-m", moduleToRun];
+        const pythonArgs = ["-u", "-m", moduleToRun];
+        const argv = [...spawnArgsPrefix, ...pythonArgs];
         (0, import_build_utils7.debug)(
-          `Starting ASGI dev server (${framework}): ${pythonCmd} ${argv.join(" ")}`
+          `Starting ASGI dev server (${framework}): ${spawnCommand} ${argv.join(" ")}`
         );
-        const child = (0, import_child_process2.spawn)(pythonCmd, argv, {
+        const child = (0, import_child_process2.spawn)(spawnCommand, argv, {
           cwd: workPath,
           env,
           stdio: ["inherit", "pipe", "pipe"]
@@ -4187,7 +4098,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
               child.stderr?.removeListener("data", onDetect);
               const port2 = Number(portMatch[1]);
               resolveChildReady({ port: port2, pid: child.pid });
-              resolve2();
+              resolve();
             }
           }
         };
@@ -4216,9 +4127,10 @@ If you are using a virtual environment, activate it before running "vercel dev",
           env.PYTHONPATH = existingPythonPath ? `${vercelPythonDir}:${existingPythonPath}` : vercelPythonDir;
         }
         const moduleToRun = devShimModule || modulePath;
-        const argv = ["-u", "-m", moduleToRun];
-        (0, import_build_utils7.debug)(`Starting Flask dev server: ${pythonCmd} ${argv.join(" ")}`);
-        const child = (0, import_child_process2.spawn)(pythonCmd, argv, {
+        const pythonArgs = ["-u", "-m", moduleToRun];
+        const argv = [...spawnArgsPrefix, ...pythonArgs];
+        (0, import_build_utils7.debug)(`Starting Flask dev server: ${spawnCommand} ${argv.join(" ")}`);
+        const child = (0, import_child_process2.spawn)(spawnCommand, argv, {
           cwd: workPath,
           env,
           stdio: ["inherit", "pipe", "pipe"]
@@ -4250,7 +4162,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
               child.stderr?.removeListener("data", onDetect);
               const port2 = Number(portMatch[1]);
               resolveChildReady({ port: port2, pid: child.pid });
-              resolve2();
+              resolve();
             }
           }
         };
@@ -4522,14 +4434,9 @@ var build = async ({
     const { projectDir } = await ensureUvProject({
       workPath,
       entryDirectory,
-      fsFiles,
       repoRootPath,
-      pythonPath: pythonVersion.pythonPath,
-      pipPath: pythonVersion.pipPath,
       pythonVersion: pythonVersion.version,
-      uv,
-      venvPath,
-      meta
+      uv
     });
     await uv.sync({
       venvPath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "6.9.0",
+  "version": "6.11.0",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -15,6 +15,9 @@
     "url": "https://github.com/vercel/vercel.git",
     "directory": "packages/python"
   },
+  "dependencies": {
+    "@vercel/python-analysis": "0.4.0"
+  },
   "devDependencies": {
     "@renovatebot/pep440": "4.2.1",
     "@types/execa": "^0.9.0",
@@ -31,7 +34,7 @@
     "smol-toml": "1.5.2",
     "vitest": "2.1.4",
     "which": "3.0.0",
-    "@vercel/build-utils": "13.3.3",
+    "@vercel/build-utils": "13.3.5",
     "@vercel/error-utils": "2.0.3"
   },
   "scripts": {

package/vc_init_dev_asgi.py

@@ -75,13 +75,23 @@ async def app(scope, receive, send):
 
 
 if __name__ == '__main__':
-    # Development runner for ASGI: prefer uvicorn, then hypercorn.
+    # Development runner for ASGI: prefer fastapi dev, then uvicorn, then hypercorn.
     # Bind to localhost on an ephemeral port and emit a recognizable log line
     # so the caller can detect the bound port.
     host = '127.0.0.1'
+
+    try:
+        from fastapi_cli.cli import dev
+    except ImportError:
+        dev = None
+
+    if dev is not None:
+        dev(entrypoint='vc_init_dev_asgi:app', host=host, port=0, reload=True)
+        sys.exit(0)
+
     try:
         import uvicorn
-        uvicorn.run('vc_init_dev_asgi:app', host=host, port=0, use_colors=True)
+        uvicorn.run('vc_init_dev_asgi:app', host=host, port=0, use_colors=True, reload=True)
     except Exception:
         try:
             import asyncio

package/vc_init_dev_wsgi.py

@@ -112,7 +112,7 @@ if __name__ == "__main__":
     host = "127.0.0.1"
     try:
         from werkzeug.serving import run_simple
-        run_simple(host, 0, app, use_reloader=False)
+        run_simple(host, 0, app, use_reloader=True)
     except Exception:
         import sys
         print(_color("Werkzeug not installed; falling back to wsgiref (no reloader).", _YELLOW), file=sys.stderr)