@vercel/python 6.1.1 → 6.1.3

package/dist/index.js

@@ -48,7 +48,7 @@ var require_windows = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs6 = require("fs");
+    var fs5 = require("fs");
     function checkPathExt(path, options) {
       var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
       if (!pathext) {
@@ -73,12 +73,12 @@ var require_windows = __commonJS({
       return checkPathExt(path, options);
     }
     function isexe(path, options, cb) {
-      fs6.stat(path, function(er, stat) {
+      fs5.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, path, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs6.statSync(path), path, options);
+      return checkStat(fs5.statSync(path), path, options);
     }
   }
 });
@@ -88,14 +88,14 @@ var require_mode = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js"(exports, module2) {
     module2.exports = isexe;
     isexe.sync = sync;
-    var fs6 = require("fs");
+    var fs5 = require("fs");
     function isexe(path, options, cb) {
-      fs6.stat(path, function(er, stat) {
+      fs5.stat(path, function(er, stat) {
         cb(er, er ? false : checkStat(stat, options));
       });
     }
     function sync(path, options) {
-      return checkStat(fs6.statSync(path), options);
+      return checkStat(fs5.statSync(path), options);
     }
     function checkStat(stat, options) {
       return stat.isFile() && checkMode(stat, options);
@@ -119,7 +119,7 @@ var require_mode = __commonJS({
 // ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
 var require_isexe = __commonJS({
   "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports, module2) {
-    var fs6 = require("fs");
+    var fs5 = require("fs");
     var core;
     if (process.platform === "win32" || global.TESTING_WINDOWS) {
       core = require_windows();
@@ -395,7 +395,7 @@ var require_shebang_command = __commonJS({
 var require_readShebang = __commonJS({
   "../../node_modules/.pnpm/cross-spawn@6.0.5/node_modules/cross-spawn/lib/util/readShebang.js"(exports, module2) {
     "use strict";
-    var fs6 = require("fs");
+    var fs5 = require("fs");
     var shebangCommand = require_shebang_command();
     function readShebang(command) {
       const size = 150;
@@ -408,9 +408,9 @@ var require_readShebang = __commonJS({
       }
       let fd;
       try {
-        fd = fs6.openSync(command, "r");
-        fs6.readSync(fd, buffer, 0, size, 0);
-        fs6.closeSync(fd);
+        fd = fs5.openSync(command, "r");
+        fs5.readSync(fd, buffer, 0, size, 0);
+        fs5.closeSync(fd);
       } catch (e) {
       }
       return shebangCommand(buffer.toString());
@@ -1498,7 +1498,7 @@ var require_parse = __commonJS({
     var escape = require_escape();
     var readShebang = require_readShebang();
     var semver = require_semver();
-    var isWin2 = 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 (!isWin2) {
+      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 (isWin2) {
+      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 isWin2 = 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 (!isWin2) {
+      if (!isWin3) {
         return;
       }
       const originalEmit = cp.emit;
@@ -1604,13 +1604,13 @@ var require_enoent = __commonJS({
       };
     }
     function verifyENOENT(status, parsed) {
-      if (isWin2 && status === 1 && !parsed.file) {
+      if (isWin3 && status === 1 && !parsed.file) {
         return notFoundError(parsed.original, "spawn");
       }
       return null;
     }
     function verifyENOENTSync(status, parsed) {
-      if (isWin2 && status === 1 && !parsed.file) {
+      if (isWin3 && status === 1 && !parsed.file) {
         return notFoundError(parsed.original, "spawnSync");
       }
       return null;
@@ -1895,9 +1895,9 @@ var require_pump = __commonJS({
   "../../node_modules/.pnpm/pump@3.0.2/node_modules/pump/index.js"(exports, module2) {
     var once = require_once();
     var eos = require_end_of_stream();
-    var fs6;
+    var fs5;
     try {
-      fs6 = require("fs");
+      fs5 = require("fs");
     } catch (e) {
     }
     var noop = function() {
@@ -1909,9 +1909,9 @@ var require_pump = __commonJS({
     var isFS = function(stream) {
       if (!ancient)
         return false;
-      if (!fs6)
+      if (!fs5)
         return false;
-      return (stream instanceof (fs6.ReadStream || noop) || stream instanceof (fs6.WriteStream || noop)) && isFn(stream.close);
+      return (stream instanceof (fs5.ReadStream || noop) || stream instanceof (fs5.WriteStream || noop)) && isFn(stream.close);
     };
     var isRequest = function(stream) {
       return stream.setHeader && isFn(stream.abort);
@@ -2143,7 +2143,7 @@ var require_signal_exit = __commonJS({
     } else {
       assert = require("assert");
       signals = require_signals();
-      isWin2 = /^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 (isWin2 && 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 isWin2;
+    var isWin3;
     var EE;
     var emitter;
     var unload;
@@ -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: join6, delimiter, 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}`);
@@ -2680,7 +2680,7 @@ var require_lib = __commonJS({
     var getPathPart = (raw, cmd) => {
       const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
       const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
-      return prefix + join7(pathPart, cmd);
+      return prefix + join6(pathPart, cmd);
     };
     var which3 = async (cmd, opt = {}) => {
       const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
@@ -2748,20 +2748,147 @@ __export(src_exports, {
   version: () => version
 });
 module.exports = __toCommonJS(src_exports);
-var import_fs6 = __toESM(require("fs"));
+var import_fs5 = __toESM(require("fs"));
 var import_util = require("util");
-var import_path6 = require("path");
-var import_build_utils8 = require("@vercel/build-utils");
+var import_path5 = require("path");
+var import_build_utils7 = require("@vercel/build-utils");
 
 // src/install.ts
 var import_execa = __toESM(require_execa());
-var import_fs = __toESM(require("fs"));
+var import_fs2 = __toESM(require("fs"));
 var import_os = __toESM(require("os"));
-var import_path = require("path");
+var import_path2 = require("path");
 var import_which = __toESM(require_lib());
+var import_build_utils2 = require("@vercel/build-utils");
+
+// src/utils.ts
+var import_fs = __toESM(require("fs"));
+var import_path = require("path");
 var import_build_utils = require("@vercel/build-utils");
+var execa = require_execa();
 var isWin = process.platform === "win32";
-var uvExec = isWin ? "uv.exe" : "uv";
+var isInVirtualEnv = () => {
+  return process.env.VIRTUAL_ENV;
+};
+function getVenvBinDir(venvPath) {
+  return (0, import_path.join)(venvPath, isWin ? "Scripts" : "bin");
+}
+function useVirtualEnv(workPath, env, systemPython) {
+  const venvDirs = [".venv", "venv"];
+  let pythonCmd = systemPython;
+  for (const venv of venvDirs) {
+    const venvRoot = (0, import_path.join)(workPath, venv);
+    const binDir = process.platform === "win32" ? (0, import_path.join)(venvRoot, "Scripts") : (0, import_path.join)(venvRoot, "bin");
+    const candidates = process.platform === "win32" ? [(0, import_path.join)(binDir, "python.exe"), (0, import_path.join)(binDir, "python")] : [(0, import_path.join)(binDir, "python3"), (0, import_path.join)(binDir, "python")];
+    const found = candidates.find((p) => import_fs.default.existsSync(p));
+    if (found) {
+      pythonCmd = found;
+      env.VIRTUAL_ENV = venvRoot;
+      env.PATH = `${binDir}${import_path.delimiter}${env.PATH || ""}`;
+      return { pythonCmd, venvRoot };
+    }
+  }
+  return { pythonCmd };
+}
+function createVenvEnv(venvPath, baseEnv = process.env) {
+  const env = { ...baseEnv, VIRTUAL_ENV: venvPath };
+  const binDir = getVenvBinDir(venvPath);
+  const existingPath = env.PATH || process.env.PATH || "";
+  env.PATH = existingPath ? `${binDir}${import_path.delimiter}${existingPath}` : binDir;
+  return env;
+}
+async function ensureVenv({
+  pythonPath,
+  venvPath
+}) {
+  const marker = (0, import_path.join)(venvPath, "pyvenv.cfg");
+  try {
+    await import_fs.default.promises.access(marker);
+    return;
+  } catch {
+  }
+  await import_fs.default.promises.mkdir(venvPath, { recursive: true });
+  console.log(`Creating virtual environment at "${venvPath}"...`);
+  await execa(pythonPath, ["-m", "venv", venvPath]);
+}
+function getVenvPythonBin(venvPath) {
+  return (0, import_path.join)(getVenvBinDir(venvPath), isWin ? "python.exe" : "python");
+}
+async function runPyprojectScript(workPath, scriptNames, env) {
+  const pyprojectPath = (0, import_path.join)(workPath, "pyproject.toml");
+  if (!import_fs.default.existsSync(pyprojectPath))
+    return false;
+  let pyproject = null;
+  try {
+    pyproject = await (0, import_build_utils.readConfigFile)(pyprojectPath);
+  } catch {
+    console.error("Failed to parse pyproject.toml");
+    return false;
+  }
+  const scripts = pyproject?.tool?.vercel?.scripts || {};
+  const candidates = typeof scriptNames === "string" ? [scriptNames] : Array.from(scriptNames);
+  const scriptToRun = candidates.find((name) => Boolean(scripts[name]));
+  if (!scriptToRun)
+    return false;
+  const systemPython = process.platform === "win32" ? "python" : "python3";
+  const finalEnv = { ...process.env, ...env };
+  useVirtualEnv(workPath, finalEnv, systemPython);
+  const scriptCommand = scripts[scriptToRun];
+  if (typeof scriptCommand === "string" && scriptCommand.trim()) {
+    console.log(`Executing: ${scriptCommand}`);
+    await (0, import_build_utils.execCommand)(scriptCommand, {
+      cwd: workPath,
+      env: finalEnv
+    });
+    return true;
+  }
+  return false;
+}
+async function runUvCommand(options) {
+  const { uvPath, args, cwd, venvPath } = options;
+  const pretty = `uv ${args.join(" ")}`;
+  (0, import_build_utils.debug)(`Running "${pretty}"...`);
+  if (!uvPath) {
+    throw new Error(`uv is required to run "${pretty}" but is not available`);
+  }
+  try {
+    await execa(uvPath, args, {
+      cwd,
+      env: createVenvEnv(venvPath)
+    });
+    return true;
+  } catch (err) {
+    const error = new Error(
+      `Failed to run "${pretty}": ${err instanceof Error ? err.message : String(err)}`
+    );
+    if (err && typeof err === "object") {
+      if ("code" in err) {
+        error.code = err.code;
+      } else if ("signal" in err) {
+        error.code = err.signal;
+      }
+    }
+    throw error;
+  }
+}
+function findDir({
+  file,
+  entryDirectory,
+  workPath,
+  fsFiles
+}) {
+  if (fsFiles[(0, import_path.join)(entryDirectory, file)]) {
+    return (0, import_path.join)(workPath, entryDirectory);
+  }
+  if (fsFiles[file]) {
+    return workPath;
+  }
+  return null;
+}
+
+// src/install.ts
+var isWin2 = process.platform === "win32";
+var uvExec = isWin2 ? "uv.exe" : "uv";
 var makeDependencyCheckCode = (dependency) => `
 from importlib import util
 dep = '${dependency}'.replace('-', '_')
@@ -2776,7 +2903,7 @@ async function isInstalled(pythonPath, dependency, cwd) {
       {
         stdio: "pipe",
         cwd,
-        env: { ...process.env, PYTHONPATH: (0, import_path.join)(cwd, resolveVendorDir()) }
+        env: { ...process.env, PYTHONPATH: (0, import_path2.join)(cwd, resolveVendorDir()) }
       }
     );
     return stdout.startsWith(cwd);
@@ -2799,7 +2926,7 @@ async function areRequirementsInstalled(pythonPath, requirementsPath, cwd) {
       {
         stdio: "pipe",
         cwd,
-        env: { ...process.env, PYTHONPATH: (0, import_path.join)(cwd, resolveVendorDir()) }
+        env: { ...process.env, PYTHONPATH: (0, import_path2.join)(cwd, resolveVendorDir()) }
       }
     );
     return true;
@@ -2807,10 +2934,334 @@ async function areRequirementsInstalled(pythonPath, requirementsPath, cwd) {
     return false;
   }
 }
+async function runUvSync({
+  uvPath,
+  venvPath,
+  projectDir,
+  locked
+}) {
+  const args = ["sync", "--active", "--no-dev"];
+  if (locked) {
+    args.push("--locked");
+  }
+  args.push("--no-editable");
+  await runUvCommand({
+    uvPath,
+    args,
+    cwd: projectDir,
+    venvPath
+  });
+}
+async function getSitePackagesDirs(pythonBin) {
+  const code = `
+import json
+import sysconfig
+paths = []
+for key in ("purelib", "platlib"):
+    candidate = sysconfig.get_path(key)
+    if candidate and candidate not in paths:
+        paths.append(candidate)
+print(json.dumps(paths))
+`.trim();
+  const { stdout } = await (0, import_execa.default)(pythonBin, ["-c", code]);
+  try {
+    const parsed = JSON.parse(stdout);
+    if (Array.isArray(parsed)) {
+      return parsed.filter((p) => typeof p === "string");
+    }
+  } catch (err) {
+    (0, import_build_utils2.debug)("Failed to parse site-packages output", err);
+  }
+  return [];
+}
+async function getVenvSitePackagesDirs(venvPath) {
+  const pythonBin = getVenvPythonBin(venvPath);
+  return getSitePackagesDirs(pythonBin);
+}
 function resolveVendorDir() {
   const vendorDir = process.env.VERCEL_PYTHON_VENDOR_DIR || "_vendor";
   return vendorDir;
 }
+async function detectInstallSource({
+  workPath,
+  entryDirectory,
+  fsFiles
+}) {
+  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_path2.join)(uvLockDir, "uv.lock");
+  } else if (pyprojectDir) {
+    manifestType = "pyproject.toml";
+    manifestPath = (0, import_path2.join)(pyprojectDir, "pyproject.toml");
+  } else if (pipfileLockDir) {
+    manifestType = "Pipfile.lock";
+    manifestPath = (0, import_path2.join)(pipfileLockDir, "Pipfile.lock");
+  } else if (pipfileDir) {
+    manifestType = "Pipfile";
+    manifestPath = (0, import_path2.join)(pipfileDir, "Pipfile");
+  } else if (requirementsDir) {
+    manifestType = "requirements.txt";
+    manifestPath = (0, import_path2.join)(requirementsDir, "requirements.txt");
+  }
+  let manifestContent;
+  if (manifestPath) {
+    try {
+      manifestContent = await import_fs2.default.promises.readFile(manifestPath, "utf8");
+    } catch (err) {
+      (0, import_build_utils2.debug)("Failed to read install manifest contents", err);
+    }
+  }
+  return { manifestPath, manifestType, manifestContent };
+}
+async function createPyprojectToml({
+  projectName,
+  pyprojectPath,
+  dependencies
+}) {
+  const requiresPython = ">=3.12";
+  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_fs2.default.promises.writeFile(pyprojectPath, content);
+}
+async function uvLock({
+  projectDir,
+  uvPath
+}) {
+  const args = ["lock"];
+  const pretty = `${uvPath} ${args.join(" ")}`;
+  (0, import_build_utils2.debug)(`Running "${pretty}" in ${projectDir}...`);
+  try {
+    await (0, import_execa.default)(uvPath, args, { cwd: projectDir });
+  } catch (err) {
+    throw new Error(
+      `Failed to run "${pretty}": ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+async function uvAddDependencies({
+  projectDir,
+  uvPath,
+  venvPath,
+  dependencies
+}) {
+  const toAdd = dependencies.filter(Boolean);
+  if (!toAdd.length)
+    return;
+  const args = ["add", "--active", ...toAdd];
+  const pretty = `${uvPath} ${args.join(" ")}`;
+  (0, import_build_utils2.debug)(`Running "${pretty}" in ${projectDir}...`);
+  await runUvCommand({ uvPath, args, cwd: projectDir, venvPath });
+}
+async function uvAddFromFile({
+  projectDir,
+  uvPath,
+  venvPath,
+  requirementsPath
+}) {
+  const args = ["add", "--active", "-r", requirementsPath];
+  const pretty = `${uvPath} ${args.join(" ")}`;
+  (0, import_build_utils2.debug)(`Running "${pretty}" in ${projectDir}...`);
+  await runUvCommand({ uvPath, args, cwd: projectDir, venvPath });
+}
+function getDependencyName(spec) {
+  const match = spec.match(/^[A-Za-z0-9_.-]+/);
+  return match ? match[0].toLowerCase() : spec.toLowerCase();
+}
+async function filterMissingRuntimeDependencies({
+  pyprojectPath,
+  runtimeDependencies
+}) {
+  let declared = [];
+  try {
+    const config = await (0, import_build_utils2.readConfigFile)(pyprojectPath);
+    declared = config?.project?.dependencies || [];
+  } catch (err) {
+    (0, import_build_utils2.debug)("Failed to parse pyproject.toml when filtering runtime deps", err);
+  }
+  const declaredNames = new Set(declared.map(getDependencyName));
+  return runtimeDependencies.filter((spec) => {
+    const name = getDependencyName(spec);
+    return !declaredNames.has(name);
+  });
+}
+async function ensureUvProject({
+  workPath,
+  entryDirectory,
+  fsFiles,
+  pythonPath,
+  pipPath,
+  uvPath,
+  venvPath,
+  meta,
+  runtimeDependencies
+}) {
+  const installInfo = await detectInstallSource({
+    workPath,
+    entryDirectory,
+    fsFiles
+  });
+  const { manifestType, manifestPath } = installInfo;
+  let projectDir;
+  let pyprojectPath;
+  if (manifestType === "uv.lock") {
+    if (!manifestPath) {
+      throw new Error("Expected uv.lock path to be resolved, but it was null");
+    }
+    projectDir = (0, import_path2.dirname)(manifestPath);
+    pyprojectPath = (0, import_path2.join)(projectDir, "pyproject.toml");
+    if (!import_fs2.default.existsSync(pyprojectPath)) {
+      throw new Error(
+        `Expected "pyproject.toml" next to "uv.lock" in "${projectDir}"`
+      );
+    }
+    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"
+      );
+    }
+    projectDir = (0, import_path2.dirname)(manifestPath);
+    pyprojectPath = manifestPath;
+    console.log("Installing required dependencies from pyproject.toml...");
+    const lockPath2 = (0, import_path2.join)(projectDir, "uv.lock");
+    if (!import_fs2.default.existsSync(lockPath2)) {
+      await uvLock({ projectDir, uvPath });
+    }
+  } 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_path2.dirname)(manifestPath);
+    console.log(`Installing required dependencies from ${manifestType}...`);
+    const exportedReq = await exportRequirementsFromPipfile({
+      pythonPath,
+      pipPath,
+      uvPath,
+      projectDir,
+      meta
+    });
+    pyprojectPath = (0, import_path2.join)(projectDir, "pyproject.toml");
+    if (!import_fs2.default.existsSync(pyprojectPath)) {
+      await createPyprojectToml({
+        projectName: "app",
+        pyprojectPath,
+        dependencies: []
+      });
+    }
+    await uvAddFromFile({
+      projectDir,
+      uvPath,
+      venvPath,
+      requirementsPath: exportedReq
+    });
+  } else if (manifestType === "requirements.txt") {
+    if (!manifestPath) {
+      throw new Error(
+        "Expected requirements.txt path to be resolved, but it was null"
+      );
+    }
+    projectDir = (0, import_path2.dirname)(manifestPath);
+    pyprojectPath = (0, import_path2.join)(projectDir, "pyproject.toml");
+    console.log(
+      "Installing required dependencies from requirements.txt with uv..."
+    );
+    if (!import_fs2.default.existsSync(pyprojectPath)) {
+      await createPyprojectToml({
+        projectName: "app",
+        pyprojectPath,
+        dependencies: []
+      });
+    }
+    await uvAddFromFile({
+      projectDir,
+      uvPath,
+      venvPath,
+      requirementsPath: manifestPath
+    });
+  } else {
+    projectDir = workPath;
+    pyprojectPath = (0, import_path2.join)(projectDir, "pyproject.toml");
+    console.log(
+      "No Python manifest found; creating an empty pyproject.toml and uv.lock..."
+    );
+    await createPyprojectToml({
+      projectName: "app",
+      pyprojectPath,
+      dependencies: []
+    });
+    await uvLock({ projectDir, uvPath });
+  }
+  if (runtimeDependencies.length) {
+    const missingRuntimeDeps = await filterMissingRuntimeDependencies({
+      pyprojectPath,
+      runtimeDependencies
+    });
+    if (missingRuntimeDeps.length) {
+      await uvAddDependencies({
+        projectDir,
+        uvPath,
+        venvPath,
+        dependencies: missingRuntimeDeps
+      });
+    }
+  }
+  const lockPath = (0, import_path2.join)(projectDir, "uv.lock");
+  if (!import_fs2.default.existsSync(lockPath)) {
+    throw new Error(
+      `Expected "uv.lock" to exist in "${projectDir}" after preparing uv project`
+    );
+  }
+  return { projectDir, pyprojectPath, lockPath };
+}
 async function getGlobalScriptsDir(pythonPath) {
   const code = `import sysconfig; print(sysconfig.get_path('scripts'))`;
   try {
@@ -2818,7 +3269,7 @@ async function getGlobalScriptsDir(pythonPath) {
     const out = stdout.trim();
     return out || null;
   } catch (err) {
-    (0, import_build_utils.debug)("Failed to resolve Python global scripts directory", err);
+    (0, import_build_utils2.debug)("Failed to resolve Python global scripts directory", err);
     return null;
   }
 }
@@ -2832,12 +3283,12 @@ async function getUserScriptsDir(pythonPath) {
     const out = stdout.trim();
     return out || null;
   } catch (err) {
-    (0, import_build_utils.debug)("Failed to resolve Python user scripts directory", err);
+    (0, import_build_utils2.debug)("Failed to resolve Python user scripts directory", err);
     return null;
   }
 }
 async function pipInstall(pipPath, uvPath, workPath, args, targetDir) {
-  const target = targetDir ? (0, import_path.join)(targetDir, resolveVendorDir()) : resolveVendorDir();
+  const target = targetDir ? (0, import_path2.join)(targetDir, resolveVendorDir()) : resolveVendorDir();
   process.env.PIP_USER = "0";
   if (uvPath) {
     const uvArgs = [
@@ -2847,10 +3298,10 @@ async function pipInstall(pipPath, uvPath, workPath, args, targetDir) {
       "--no-cache-dir",
       "--target",
       target,
-      ...args
+      ...filterUnsafeUvPipArgs(args)
     ];
     const prettyUv = `${uvPath} ${uvArgs.join(" ")}`;
-    (0, import_build_utils.debug)(`Running "${prettyUv}"...`);
+    (0, import_build_utils2.debug)(`Running "${prettyUv}"...`);
     try {
       await (0, import_execa.default)(uvPath, uvArgs, {
         cwd: workPath
@@ -2858,7 +3309,7 @@ async function pipInstall(pipPath, uvPath, workPath, args, targetDir) {
       return;
     } catch (err) {
       console.log(`Failed to run "${prettyUv}", falling back to pip`);
-      (0, import_build_utils.debug)(`error: ${err}`);
+      (0, import_build_utils2.debug)(`error: ${err}`);
     }
   }
   const cmdArgs = [
@@ -2871,14 +3322,14 @@ async function pipInstall(pipPath, uvPath, workPath, args, targetDir) {
     ...args
   ];
   const pretty = `${pipPath} ${cmdArgs.join(" ")}`;
-  (0, import_build_utils.debug)(`Running "${pretty}"...`);
+  (0, import_build_utils2.debug)(`Running "${pretty}"...`);
   try {
     await (0, import_execa.default)(pipPath, cmdArgs, {
       cwd: workPath
     });
   } catch (err) {
     console.log(`Failed to run "${pretty}"`);
-    (0, import_build_utils.debug)(`error: ${err}`);
+    (0, import_build_utils2.debug)(`error: ${err}`);
     throw err;
   }
 }
@@ -2889,38 +3340,38 @@ async function maybeFindUvBin(pythonPath) {
   try {
     const globalScriptsDir = await getGlobalScriptsDir(pythonPath);
     if (globalScriptsDir) {
-      const uvPath = (0, import_path.join)(globalScriptsDir, uvExec);
-      if (import_fs.default.existsSync(uvPath))
+      const uvPath = (0, import_path2.join)(globalScriptsDir, uvExec);
+      if (import_fs2.default.existsSync(uvPath))
         return uvPath;
     }
   } catch (err) {
-    (0, import_build_utils.debug)("Failed to resolve Python global scripts directory", err);
+    (0, import_build_utils2.debug)("Failed to resolve Python global scripts directory", err);
   }
   try {
     const userScriptsDir = await getUserScriptsDir(pythonPath);
     if (userScriptsDir) {
-      const uvPath = (0, import_path.join)(userScriptsDir, uvExec);
-      if (import_fs.default.existsSync(uvPath))
+      const uvPath = (0, import_path2.join)(userScriptsDir, uvExec);
+      if (import_fs2.default.existsSync(uvPath))
         return uvPath;
     }
   } catch (err) {
-    (0, import_build_utils.debug)("Failed to resolve Python user scripts directory", err);
+    (0, import_build_utils2.debug)("Failed to resolve Python user scripts directory", err);
   }
   try {
     const candidates = [];
-    if (!isWin) {
-      candidates.push((0, import_path.join)(import_os.default.homedir(), ".local", "bin", "uv"));
+    if (!isWin2) {
+      candidates.push((0, import_path2.join)(import_os.default.homedir(), ".local", "bin", "uv"));
       candidates.push("/usr/local/bin/uv");
       candidates.push("/opt/homebrew/bin/uv");
     } else {
       candidates.push("C:\\Users\\Public\\uv\\uv.exe");
     }
     for (const p of candidates) {
-      if (import_fs.default.existsSync(p))
+      if (import_fs2.default.existsSync(p))
         return p;
     }
   } catch (err) {
-    (0, import_build_utils.debug)("Failed to resolve uv fallback paths", err);
+    (0, import_build_utils2.debug)("Failed to resolve uv fallback paths", err);
   }
   return null;
 }
@@ -2968,7 +3419,7 @@ async function installRequirement({
 }) {
   const actualTargetDir = targetDir || workPath;
   if (meta.isDev && await isInstalled(pythonPath, dependency, actualTargetDir)) {
-    (0, import_build_utils.debug)(
+    (0, import_build_utils2.debug)(
       `Skipping ${dependency} dependency installation, already installed in ${actualTargetDir}`
     );
     return;
@@ -2988,7 +3439,7 @@ async function installRequirementsFile({
 }) {
   const actualTargetDir = targetDir || workPath;
   if (meta.isDev && await areRequirementsInstalled(pythonPath, filePath, actualTargetDir)) {
-    (0, import_build_utils.debug)(`Skipping requirements file installation, already installed`);
+    (0, import_build_utils2.debug)(`Skipping requirements file installation, already installed`);
     return;
   }
   await pipInstall(
@@ -2999,35 +3450,8 @@ async function installRequirementsFile({
     targetDir
   );
 }
-async function exportRequirementsFromUv(projectDir, uvPath, options = {}) {
-  const { locked = false } = options;
-  if (!uvPath) {
-    throw new Error("uv is not available to export requirements");
-  }
-  const args = [
-    "export",
-    "--no-default-groups",
-    "--no-emit-workspace",
-    "--no-editable"
-  ];
-  if (locked) {
-    args.push("--frozen");
-  }
-  (0, import_build_utils.debug)(`Running "${uvPath} ${args.join(" ")}" in ${projectDir}...`);
-  let stdout;
-  try {
-    const { stdout: out } = await (0, import_execa.default)(uvPath, args, { cwd: projectDir });
-    stdout = out;
-  } catch (err) {
-    throw new Error(
-      `Failed to run "${uvPath} ${args.join(" ")}": ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  const tmpDir = await import_fs.default.promises.mkdtemp((0, import_path.join)(import_os.default.tmpdir(), "vercel-uv-"));
-  const outPath = (0, import_path.join)(tmpDir, "requirements.uv.txt");
-  await import_fs.default.promises.writeFile(outPath, stdout);
-  (0, import_build_utils.debug)(`Exported requirements to ${outPath}`);
-  return outPath;
+function filterUnsafeUvPipArgs(args) {
+  return args.filter((arg) => arg !== "--no-warn-script-location");
 }
 async function exportRequirementsFromPipfile({
   pythonPath,
@@ -3036,8 +3460,8 @@ async function exportRequirementsFromPipfile({
   projectDir,
   meta
 }) {
-  const tempDir = await import_fs.default.promises.mkdtemp(
-    (0, import_path.join)(import_os.default.tmpdir(), "vercel-pipenv-")
+  const tempDir = await import_fs2.default.promises.mkdtemp(
+    (0, import_path2.join)(import_os.default.tmpdir(), "vercel-pipenv-")
   );
   await installRequirement({
     pythonPath,
@@ -3049,9 +3473,9 @@ async function exportRequirementsFromPipfile({
     args: ["--no-warn-script-location"],
     uvPath
   });
-  const tempVendorDir = (0, import_path.join)(tempDir, resolveVendorDir());
-  const convertCmd = isWin ? (0, import_path.join)(tempVendorDir, "Scripts", "pipfile2req.exe") : (0, import_path.join)(tempVendorDir, "bin", "pipfile2req");
-  (0, import_build_utils.debug)(`Running "${convertCmd}" in ${projectDir}...`);
+  const tempVendorDir = (0, import_path2.join)(tempDir, resolveVendorDir());
+  const convertCmd = isWin2 ? (0, import_path2.join)(tempVendorDir, "Scripts", "pipfile2req.exe") : (0, import_path2.join)(tempVendorDir, "bin", "pipfile2req");
+  (0, import_build_utils2.debug)(`Running "${convertCmd}" in ${projectDir}...`);
   let stdout;
   try {
     const { stdout: out } = await (0, import_execa.default)(convertCmd, [], {
@@ -3064,17 +3488,46 @@ async function exportRequirementsFromPipfile({
       `Failed to run "${convertCmd}": ${err instanceof Error ? err.message : String(err)}`
     );
   }
-  const outPath = (0, import_path.join)(tempDir, "requirements.pipenv.txt");
-  await import_fs.default.promises.writeFile(outPath, stdout);
-  (0, import_build_utils.debug)(`Exported pipfile requirements to ${outPath}`);
+  const outPath = (0, import_path2.join)(tempDir, "requirements.pipenv.txt");
+  await import_fs2.default.promises.writeFile(outPath, stdout);
+  (0, import_build_utils2.debug)(`Exported pipfile requirements to ${outPath}`);
   return outPath;
 }
+async function mirrorSitePackagesIntoVendor({
+  venvPath,
+  vendorDirName
+}) {
+  const vendorFiles = {};
+  try {
+    const sitePackageDirs = await getVenvSitePackagesDirs(venvPath);
+    for (const dir of sitePackageDirs) {
+      if (!import_fs2.default.existsSync(dir))
+        continue;
+      const dirFiles = await (0, import_build_utils2.glob)("**", dir);
+      for (const relativePath of Object.keys(dirFiles)) {
+        if (relativePath.endsWith(".pyc") || relativePath.includes("__pycache__")) {
+          continue;
+        }
+        const srcFsPath = (0, import_path2.join)(dir, relativePath);
+        const bundlePath = (0, import_path2.join)(vendorDirName, relativePath).replace(
+          /\\/g,
+          "/"
+        );
+        vendorFiles[bundlePath] = new import_build_utils2.FileFsRef({ fsPath: srcFsPath });
+      }
+    }
+  } catch (err) {
+    console.log("Failed to collect site-packages from virtual environment");
+    throw err;
+  }
+  return vendorFiles;
+}
 
 // src/index.ts
-var import_build_utils9 = require("@vercel/build-utils");
+var import_build_utils8 = require("@vercel/build-utils");
 
 // src/version.ts
-var import_build_utils2 = require("@vercel/build-utils");
+var import_build_utils3 = require("@vercel/build-utils");
 var import_which2 = __toESM(require_lib());
 var allOptions = [
   {
@@ -3125,7 +3578,7 @@ function getLatestPythonVersion({
   }
   const selection = allOptions.find(isInstalled2);
   if (!selection) {
-    throw new import_build_utils2.NowBuildError({
+    throw new import_build_utils3.NowBuildError({
       code: "PYTHON_NOT_FOUND",
       link: "http://vercel.link/python-version",
       message: `Unable to find any supported Python versions.`
@@ -3226,7 +3679,7 @@ function getSupportedPythonVersion({
     }
     if (requested) {
       if (isDiscontinued(requested)) {
-        throw new import_build_utils2.NowBuildError({
+        throw new import_build_utils3.NowBuildError({
           code: "BUILD_UTILS_PYTHON_VERSION_DISCONTINUED",
           link: "http://vercel.link/python-version",
           message: `Python version "${requested.version}" detected in ${source} is discontinued and must be upgraded.`
@@ -3257,7 +3710,7 @@ function getSupportedPythonVersion({
     );
   }
   if (isDiscontinued(selection)) {
-    throw new import_build_utils2.NowBuildError({
+    throw new import_build_utils3.NowBuildError({
       code: "BUILD_UTILS_PYTHON_VERSION_DISCONTINUED",
       link: "http://vercel.link/python-version",
       message: `Python version "${selection.version}" declared in project configuration is discontinued and must be upgraded.`
@@ -3287,16 +3740,16 @@ var import_path4 = require("path");
 var import_build_utils6 = require("@vercel/build-utils");
 
 // src/entrypoint.ts
-var import_fs2 = __toESM(require("fs"));
-var import_path2 = require("path");
-var import_build_utils3 = require("@vercel/build-utils");
+var import_fs3 = __toESM(require("fs"));
+var import_path3 = require("path");
 var import_build_utils4 = require("@vercel/build-utils");
+var import_build_utils5 = require("@vercel/build-utils");
 var FASTAPI_ENTRYPOINT_FILENAMES = ["app", "index", "server", "main"];
 var FASTAPI_ENTRYPOINT_DIRS = ["", "src", "app", "api"];
 var FASTAPI_CONTENT_REGEX = /(from\s+fastapi\s+import\s+FastAPI|import\s+fastapi|FastAPI\s*\()/;
 var FASTAPI_CANDIDATE_ENTRYPOINTS = FASTAPI_ENTRYPOINT_FILENAMES.flatMap(
   (filename) => FASTAPI_ENTRYPOINT_DIRS.map(
-    (dir) => import_path2.posix.join(dir, `${filename}.py`)
+    (dir) => import_path3.posix.join(dir, `${filename}.py`)
   )
 );
 function isFastapiEntrypoint(file) {
@@ -3304,7 +3757,7 @@ function isFastapiEntrypoint(file) {
     const fsPath = file.fsPath;
     if (!fsPath)
       return false;
-    const contents = import_fs2.default.readFileSync(fsPath, "utf8");
+    const contents = import_fs3.default.readFileSync(fsPath, "utf8");
     return FASTAPI_CONTENT_REGEX.test(contents);
   } catch {
     return false;
@@ -3315,7 +3768,7 @@ var FLASK_ENTRYPOINT_DIRS = ["", "src", "app", "api"];
 var FLASK_CONTENT_REGEX = /(from\s+flask\s+import\s+Flask|import\s+flask|Flask\s*\()/;
 var FLASK_CANDIDATE_ENTRYPOINTS = FLASK_ENTRYPOINT_FILENAMES.flatMap(
   (filename) => FLASK_ENTRYPOINT_DIRS.map(
-    (dir) => import_path2.posix.join(dir, `${filename}.py`)
+    (dir) => import_path3.posix.join(dir, `${filename}.py`)
   )
 );
 function isFlaskEntrypoint(file) {
@@ -3323,7 +3776,7 @@ function isFlaskEntrypoint(file) {
     const fsPath = file.fsPath;
     if (!fsPath)
       return false;
-    const contents = import_fs2.default.readFileSync(fsPath, "utf8");
+    const contents = import_fs3.default.readFileSync(fsPath, "utf8");
     return FLASK_CONTENT_REGEX.test(contents);
   } catch {
     return false;
@@ -3332,7 +3785,7 @@ function isFlaskEntrypoint(file) {
 async function detectFlaskEntrypoint(workPath, configuredEntrypoint) {
   const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
   try {
-    const fsFiles = await (0, import_build_utils3.glob)("**", workPath);
+    const fsFiles = await (0, import_build_utils4.glob)("**", workPath);
     if (fsFiles[entry])
       return entry;
     const candidates = FLASK_CANDIDATE_ENTRYPOINTS.filter(
@@ -3342,19 +3795,19 @@ async function detectFlaskEntrypoint(workPath, configuredEntrypoint) {
       const flaskEntrypoint = candidates.find(
         (c) => isFlaskEntrypoint(fsFiles[c])
       ) || candidates[0];
-      (0, import_build_utils3.debug)(`Detected Flask entrypoint: ${flaskEntrypoint}`);
+      (0, import_build_utils4.debug)(`Detected Flask entrypoint: ${flaskEntrypoint}`);
       return flaskEntrypoint;
     }
     return null;
   } catch {
-    (0, import_build_utils3.debug)("Failed to discover entrypoint for Flask");
+    (0, import_build_utils4.debug)("Failed to discover entrypoint for Flask");
     return null;
   }
 }
 async function detectFastapiEntrypoint(workPath, configuredEntrypoint) {
   const entry = configuredEntrypoint.endsWith(".py") ? configuredEntrypoint : `${configuredEntrypoint}.py`;
   try {
-    const fsFiles = await (0, import_build_utils3.glob)("**", workPath);
+    const fsFiles = await (0, import_build_utils4.glob)("**", workPath);
     if (fsFiles[entry])
       return entry;
     const candidates = FASTAPI_CANDIDATE_ENTRYPOINTS.filter(
@@ -3364,17 +3817,17 @@ async function detectFastapiEntrypoint(workPath, configuredEntrypoint) {
       const fastapiEntrypoint = candidates.find(
         (c) => isFastapiEntrypoint(fsFiles[c])
       ) || candidates[0];
-      (0, import_build_utils3.debug)(`Detected FastAPI entrypoint: ${fastapiEntrypoint}`);
+      (0, import_build_utils4.debug)(`Detected FastAPI entrypoint: ${fastapiEntrypoint}`);
       return fastapiEntrypoint;
     }
     return null;
   } catch {
-    (0, import_build_utils3.debug)("Failed to discover entrypoint for FastAPI");
+    (0, import_build_utils4.debug)("Failed to discover entrypoint for FastAPI");
     return null;
   }
 }
 async function getPyprojectEntrypoint(workPath) {
-  const pyprojectData = await (0, import_build_utils4.readConfigFile)((0, import_path2.join)(workPath, "pyproject.toml"));
+  const pyprojectData = await (0, import_build_utils5.readConfigFile)((0, import_path3.join)(workPath, "pyproject.toml"));
   if (!pyprojectData)
     return null;
   const scripts = pyprojectData.project?.scripts;
@@ -3387,7 +3840,7 @@ async function getPyprojectEntrypoint(workPath) {
   const modulePath = match[1];
   const relPath = modulePath.replace(/\./g, "/");
   try {
-    const fsFiles = await (0, import_build_utils3.glob)("**", workPath);
+    const fsFiles = await (0, import_build_utils4.glob)("**", workPath);
     const candidates = [`${relPath}.py`, `${relPath}/__init__.py`];
     for (const candidate of candidates) {
       if (fsFiles[candidate])
@@ -3395,7 +3848,7 @@ async function getPyprojectEntrypoint(workPath) {
     }
     return null;
   } catch {
-    (0, import_build_utils3.debug)("Failed to discover Python entrypoint from pyproject.toml");
+    (0, import_build_utils4.debug)("Failed to discover Python entrypoint from pyproject.toml");
     return null;
   }
 }
@@ -3411,61 +3864,6 @@ async function detectPythonEntrypoint(framework, workPath, configuredEntrypoint)
   return await getPyprojectEntrypoint(workPath);
 }
 
-// src/utils.ts
-var import_fs3 = __toESM(require("fs"));
-var import_path3 = require("path");
-var import_build_utils5 = require("@vercel/build-utils");
-var isInVirtualEnv = () => {
-  return process.env.VIRTUAL_ENV;
-};
-function useVirtualEnv(workPath, env, systemPython) {
-  const venvDirs = [".venv", "venv"];
-  let pythonCmd = systemPython;
-  for (const venv of venvDirs) {
-    const venvRoot = (0, import_path3.join)(workPath, venv);
-    const binDir = process.platform === "win32" ? (0, import_path3.join)(venvRoot, "Scripts") : (0, import_path3.join)(venvRoot, "bin");
-    const candidates = process.platform === "win32" ? [(0, import_path3.join)(binDir, "python.exe"), (0, import_path3.join)(binDir, "python")] : [(0, import_path3.join)(binDir, "python3"), (0, import_path3.join)(binDir, "python")];
-    const found = candidates.find((p) => import_fs3.default.existsSync(p));
-    if (found) {
-      pythonCmd = found;
-      env.VIRTUAL_ENV = venvRoot;
-      env.PATH = `${binDir}${import_path3.delimiter}${env.PATH || ""}`;
-      return { pythonCmd, venvRoot };
-    }
-  }
-  return { pythonCmd };
-}
-async function runPyprojectScript(workPath, scriptNames, env) {
-  const pyprojectPath = (0, import_path3.join)(workPath, "pyproject.toml");
-  if (!import_fs3.default.existsSync(pyprojectPath))
-    return false;
-  let pyproject = null;
-  try {
-    pyproject = await (0, import_build_utils5.readConfigFile)(pyprojectPath);
-  } catch {
-    console.error("Failed to parse pyproject.toml");
-    return false;
-  }
-  const scripts = pyproject?.tool?.vercel?.scripts || {};
-  const candidates = typeof scriptNames === "string" ? [scriptNames] : Array.from(scriptNames);
-  const scriptToRun = candidates.find((name) => Boolean(scripts[name]));
-  if (!scriptToRun)
-    return false;
-  const systemPython = process.platform === "win32" ? "python" : "python3";
-  const finalEnv = { ...process.env, ...env };
-  useVirtualEnv(workPath, finalEnv, systemPython);
-  const scriptCommand = scripts[scriptToRun];
-  if (typeof scriptCommand === "string" && scriptCommand.trim()) {
-    console.log(`Executing: ${scriptCommand}`);
-    await (0, import_build_utils5.execCommand)(scriptCommand, {
-      cwd: workPath,
-      env: finalEnv
-    });
-    return true;
-  }
-  return false;
-}
-
 // src/start-dev-server.ts
 function silenceNodeWarnings() {
   const original = process.emitWarning.bind(
@@ -3835,159 +4233,37 @@ If you are using a virtual environment, activate it before running "vercel dev",
   }
 };
 
-// src/uv-workspace.ts
-var import_fs5 = __toESM(require("fs"));
-var import_os2 = __toESM(require("os"));
-var import_path5 = require("path");
-var import_build_utils7 = require("@vercel/build-utils");
-function getDependencyName(spec) {
-  const match = spec.match(/^[A-Za-z0-9_.-]+/);
-  return match ? match[0] : null;
-}
-async function installUvWorkspaceDependencies({
-  repoRootPath,
-  pyprojectDir,
-  pythonPath,
-  pipPath,
-  uvPath,
-  workPath,
-  vendorBaseDir,
-  meta
-}) {
-  if (!repoRootPath || !pyprojectDir) {
-    return;
-  }
-  let rootPyproject = null;
-  try {
-    rootPyproject = await (0, import_build_utils7.readConfigFile)(
-      (0, import_path5.join)(repoRootPath, "pyproject.toml")
-    );
-  } catch (err) {
-    (0, import_build_utils7.debug)("Failed to parse workspace root pyproject.toml", err);
-  }
-  const uvTool = rootPyproject?.tool?.uv;
-  const workspaceCfg = uvTool?.workspace;
-  const sourcesCfg = uvTool?.sources;
-  if (!workspaceCfg || !sourcesCfg) {
-    return;
-  }
-  const workspaceSourceNames = new Set(
-    Object.entries(sourcesCfg).filter(([, src]) => src && src.workspace).map(([name]) => name)
-  );
-  if (!workspaceSourceNames.size) {
-    return;
-  }
-  let appPyproject = null;
-  try {
-    appPyproject = await (0, import_build_utils7.readConfigFile)(
-      (0, import_path5.join)(pyprojectDir, "pyproject.toml")
-    );
-  } catch (err) {
-    (0, import_build_utils7.debug)("Failed to parse app pyproject.toml for workspace deps", err);
-  }
-  const appDeps = appPyproject?.project?.dependencies ?? [];
-  const workspaceDepsForApp = /* @__PURE__ */ new Set();
-  for (const spec of appDeps) {
-    const name = getDependencyName(spec);
-    if (name && workspaceSourceNames.has(name)) {
-      workspaceDepsForApp.add(name);
-    }
-  }
-  if (!workspaceDepsForApp.size) {
-    return;
-  }
-  const members = workspaceCfg.members ?? [];
-  const nameToDir = /* @__PURE__ */ new Map();
-  for (const member of members) {
-    const memberDir = (0, import_path5.join)(repoRootPath, member);
-    let memberPyproject = null;
-    try {
-      memberPyproject = await (0, import_build_utils7.readConfigFile)(
-        (0, import_path5.join)(memberDir, "pyproject.toml")
-      );
-    } catch (err) {
-      (0, import_build_utils7.debug)("Failed to parse workspace member pyproject.toml", err);
-      continue;
-    }
-    const projectName = memberPyproject?.project?.name;
-    if (projectName) {
-      nameToDir.set(projectName, memberDir);
-    }
-  }
-  const requirementLines = [];
-  for (const name of workspaceDepsForApp) {
-    const dir = nameToDir.get(name);
-    if (!dir) {
-      (0, import_build_utils7.debug)(
-        `uv workspace dependency "${name}" declared but corresponding member directory not found`
-      );
-      continue;
-    }
-    requirementLines.push(dir);
-  }
-  if (!requirementLines.length) {
-    return;
-  }
-  const tmpDir = await import_fs5.default.promises.mkdtemp(
-    (0, import_path5.join)(import_os2.default.tmpdir(), "vercel-uv-workspace-")
-  );
-  const reqPath = (0, import_path5.join)(tmpDir, "requirements.workspace.txt");
-  await import_fs5.default.promises.writeFile(reqPath, requirementLines.join("\n"));
-  await installRequirementsFile({
-    pythonPath,
-    pipPath,
-    uvPath,
-    filePath: reqPath,
-    workPath,
-    targetDir: vendorBaseDir,
-    meta
-  });
-}
-
 // src/index.ts
-var readFile = (0, import_util.promisify)(import_fs6.default.readFile);
-var writeFile = (0, import_util.promisify)(import_fs6.default.writeFile);
+var readFile = (0, import_util.promisify)(import_fs5.default.readFile);
+var writeFile = (0, import_util.promisify)(import_fs5.default.writeFile);
 var version = 3;
-function findDir({
-  file,
-  entryDirectory,
-  workPath,
-  fsFiles
-}) {
-  if (fsFiles[(0, import_path6.join)(entryDirectory, file)]) {
-    return (0, import_path6.join)(workPath, entryDirectory);
-  }
-  if (fsFiles[file]) {
-    return workPath;
-  }
-  return null;
-}
 async function downloadFilesInWorkPath({
   entrypoint,
   workPath,
   files,
   meta = {}
 }) {
-  (0, import_build_utils8.debug)("Downloading user files...");
-  let downloadedFiles = await (0, import_build_utils8.download)(files, workPath, meta);
+  (0, import_build_utils7.debug)("Downloading user files...");
+  let downloadedFiles = await (0, import_build_utils7.download)(files, workPath, meta);
   if (meta.isDev) {
-    const { devCacheDir = (0, import_path6.join)(workPath, ".now", "cache") } = meta;
-    const destCache = (0, import_path6.join)(devCacheDir, (0, import_path6.basename)(entrypoint, ".py"));
-    await (0, import_build_utils8.download)(downloadedFiles, destCache);
-    downloadedFiles = await (0, import_build_utils8.glob)("**", destCache);
+    const { devCacheDir = (0, import_path5.join)(workPath, ".now", "cache") } = meta;
+    const destCache = (0, import_path5.join)(devCacheDir, (0, import_path5.basename)(entrypoint, ".py"));
+    await (0, import_build_utils7.download)(downloadedFiles, destCache);
+    downloadedFiles = await (0, import_build_utils7.glob)("**", destCache);
     workPath = destCache;
   }
   return workPath;
 }
 var build = async ({
   workPath,
-  repoRootPath,
   files: originalFiles,
   entrypoint,
   meta = {},
   config
 }) => {
   const framework = config?.framework;
+  let spawnEnv;
+  let projectInstallCommand;
   workPath = await downloadFilesInWorkPath({
     workPath,
     files: originalFiles,
@@ -3996,7 +4272,7 @@ var build = async ({
   });
   try {
     if (meta.isDev) {
-      const setupCfg = (0, import_path6.join)(workPath, "setup.cfg");
+      const setupCfg = (0, import_path5.join)(workPath, "setup.cfg");
       await writeFile(setupCfg, "[install]\nprefix=\n");
     }
   } catch (err) {
@@ -4009,8 +4285,8 @@ var build = async ({
       lockfileVersion,
       packageJsonPackageManager,
       turboSupportsCorepackHome
-    } = await (0, import_build_utils8.scanParentDirs)(workPath, true);
-    const spawnEnv = (0, import_build_utils8.getEnvForPackageManager)({
+    } = await (0, import_build_utils7.scanParentDirs)(workPath, true);
+    spawnEnv = (0, import_build_utils7.getEnvForPackageManager)({
       cliType,
       lockfileVersion,
       packageJsonPackageManager,
@@ -4020,12 +4296,9 @@ var build = async ({
     });
     const installCommand = config?.projectSettings?.installCommand;
     if (typeof installCommand === "string") {
-      if (installCommand.trim()) {
-        console.log(`Running "install" command: \`${installCommand}\`...`);
-        await (0, import_build_utils8.execCommand)(installCommand, {
-          env: spawnEnv,
-          cwd: workPath
-        });
+      const trimmed = installCommand.trim();
+      if (trimmed) {
+        projectInstallCommand = trimmed;
       } else {
         console.log('Skipping "install" command...');
       }
@@ -4034,7 +4307,7 @@ var build = async ({
     config?.buildCommand;
     if (projectBuildCommand) {
       console.log(`Running "${projectBuildCommand}"`);
-      await (0, import_build_utils8.execCommand)(projectBuildCommand, {
+      await (0, import_build_utils7.execCommand)(projectBuildCommand, {
         env: spawnEnv,
         cwd: workPath
       });
@@ -4046,7 +4319,7 @@ var build = async ({
       );
     }
   }
-  let fsFiles = await (0, import_build_utils8.glob)("**", workPath);
+  let fsFiles = await (0, import_build_utils7.glob)("**", workPath);
   if ((framework === "fastapi" || framework === "flask") && (!fsFiles[entrypoint] || !entrypoint.endsWith(".py"))) {
     const detected = await detectPythonEntrypoint(
       config.framework,
@@ -4054,13 +4327,13 @@ var build = async ({
       entrypoint
     );
     if (detected) {
-      (0, import_build_utils8.debug)(
+      (0, import_build_utils7.debug)(
         `Resolved Python entrypoint to "${detected}" (configured "${entrypoint}" not found).`
       );
       entrypoint = detected;
     } else {
       const searchedList = framework === "fastapi" ? FASTAPI_CANDIDATE_ENTRYPOINTS.join(", ") : FLASK_CANDIDATE_ENTRYPOINTS.join(", ");
-      throw new import_build_utils8.NowBuildError({
+      throw new import_build_utils7.NowBuildError({
         code: `${framework.toUpperCase()}_ENTRYPOINT_NOT_FOUND`,
         message: `No ${framework} entrypoint found. Add an 'app' script in pyproject.toml or define an entrypoint in one of: ${searchedList}.`,
         link: `https://vercel.com/docs/frameworks/backend/${framework}#exporting-the-${framework}-application`,
@@ -4068,46 +4341,42 @@ var build = async ({
       });
     }
   }
-  const entryDirectory = (0, import_path6.dirname)(entrypoint);
-  const hasReqLocal = !!fsFiles[(0, import_path6.join)(entryDirectory, "requirements.txt")];
-  const hasReqGlobal = !!fsFiles["requirements.txt"];
-  const uvLockDir = findDir({
-    file: "uv.lock",
+  const entryDirectory = (0, import_path5.dirname)(entrypoint);
+  const pyprojectDir = findDir({
+    file: "pyproject.toml",
     entryDirectory,
     workPath,
     fsFiles
   });
-  const pyprojectDir = findDir({
-    file: "pyproject.toml",
+  const pipfileLockDir = findDir({
+    file: "Pipfile.lock",
     entryDirectory,
     workPath,
     fsFiles
   });
-  const pipfileLockDir = fsFiles[(0, import_path6.join)(entryDirectory, "Pipfile.lock")] ? (0, import_path6.join)(workPath, entryDirectory) : fsFiles["Pipfile.lock"] ? workPath : null;
-  const pipfileDir = fsFiles[(0, import_path6.join)(entryDirectory, "Pipfile")] ? (0, import_path6.join)(workPath, entryDirectory) : fsFiles["Pipfile"] ? workPath : null;
   let declaredPythonVersion;
   if (pyprojectDir) {
     let requiresPython;
     try {
-      const pyproject = await (0, import_build_utils9.readConfigFile)((0, import_path6.join)(pyprojectDir, "pyproject.toml"));
+      const pyproject = await (0, import_build_utils8.readConfigFile)((0, import_path5.join)(pyprojectDir, "pyproject.toml"));
       requiresPython = pyproject?.project?.["requires-python"];
     } catch (err) {
-      (0, import_build_utils8.debug)("Failed to parse pyproject.toml", err);
+      (0, import_build_utils7.debug)("Failed to parse pyproject.toml", err);
     }
     if (typeof requiresPython === "string" && requiresPython.trim()) {
       declaredPythonVersion = {
         version: requiresPython.trim(),
         source: "pyproject.toml"
       };
-      (0, import_build_utils8.debug)(`Found requires-python "${requiresPython}" in pyproject.toml`);
+      (0, import_build_utils7.debug)(`Found requires-python "${requiresPython}" in pyproject.toml`);
     }
   } else if (pipfileLockDir) {
     let lock = {};
     try {
-      const json = await readFile((0, import_path6.join)(pipfileLockDir, "Pipfile.lock"), "utf8");
+      const json = await readFile((0, import_path5.join)(pipfileLockDir, "Pipfile.lock"), "utf8");
       lock = JSON.parse(json);
     } catch (err) {
-      throw new import_build_utils8.NowBuildError({
+      throw new import_build_utils7.NowBuildError({
         code: "INVALID_PIPFILE_LOCK",
         message: "Unable to parse Pipfile.lock"
       });
@@ -4115,191 +4384,68 @@ var build = async ({
     const pyFromLock = lock?._meta?.requires?.python_version;
     if (pyFromLock) {
       declaredPythonVersion = { version: pyFromLock, source: "Pipfile.lock" };
-      (0, import_build_utils8.debug)(`Found Python version ${pyFromLock} in Pipfile.lock`);
+      (0, import_build_utils7.debug)(`Found Python version ${pyFromLock} in Pipfile.lock`);
     }
   }
   const pythonVersion = getSupportedPythonVersion({
     isDev: meta.isDev,
     declaredPythonVersion
   });
-  fsFiles = await (0, import_build_utils8.glob)("**", workPath);
-  const requirementsTxt = (0, import_path6.join)(entryDirectory, "requirements.txt");
-  const vendorBaseDir = (0, import_path6.join)(
-    workPath,
-    ".vercel",
-    "python",
-    `py${pythonVersion.version}`,
-    entryDirectory
-  );
-  try {
-    await import_fs6.default.promises.mkdir(vendorBaseDir, { recursive: true });
-  } catch (err) {
-    console.log("Failed to create vendor cache directory");
-    throw err;
-  }
-  let installationSource;
-  if (uvLockDir && pyprojectDir) {
-    installationSource = "uv.lock";
-  } else if (pyprojectDir) {
-    installationSource = "pyproject.toml";
-  } else if (pipfileLockDir) {
-    installationSource = "Pipfile.lock";
-  } else if (pipfileDir) {
-    installationSource = "Pipfile";
-  } else if (fsFiles[requirementsTxt] || fsFiles["requirements.txt"]) {
-    installationSource = "requirements.txt";
-  }
-  if (installationSource) {
-    console.log(
-      `Installing required dependencies from ${installationSource}...`
-    );
-  } else {
-    console.log("Installing required dependencies...");
-  }
-  let uvPath = null;
-  try {
-    uvPath = await getUvBinaryOrInstall(pythonVersion.pythonPath);
-    console.log(`Using uv at "${uvPath}"`);
-  } catch (err) {
-    if (uvLockDir || pyprojectDir && !hasReqLocal && !hasReqGlobal) {
-      console.log("Failed to install uv");
-      throw new Error(
-        `uv is required for this project but failed to install: ${err instanceof Error ? err.message : String(err)}`
-      );
-    }
-    (0, import_build_utils8.debug)("Failed to install uv", err);
-  }
-  await installRequirement({
+  fsFiles = await (0, import_build_utils7.glob)("**", workPath);
+  const venvPath = (0, import_path5.join)(workPath, ".vercel", "python", ".venv");
+  await ensureVenv({
     pythonPath: pythonVersion.pythonPath,
-    pipPath: pythonVersion.pipPath,
-    uvPath,
-    dependency: "werkzeug",
-    version: "1.0.1",
-    workPath,
-    targetDir: vendorBaseDir,
-    meta
+    venvPath
   });
-  if (framework !== "flask") {
-    await installRequirement({
-      pythonPath: pythonVersion.pythonPath,
-      pipPath: pythonVersion.pipPath,
-      uvPath,
-      dependency: "uvicorn",
-      version: "0.38.0",
-      workPath,
-      targetDir: vendorBaseDir,
-      meta
+  const hasCustomInstallCommand = (framework === "fastapi" || framework === "flask") && !!projectInstallCommand;
+  if (hasCustomInstallCommand) {
+    const baseEnv = spawnEnv || process.env;
+    const pythonEnv = createVenvEnv(venvPath, baseEnv);
+    pythonEnv.VERCEL_PYTHON_VENV_PATH = venvPath;
+    const installCommand = projectInstallCommand;
+    console.log(`Running "install" command: \`${installCommand}\`...`);
+    await (0, import_build_utils7.execCommand)(installCommand, {
+      env: pythonEnv,
+      cwd: workPath
     });
-  }
-  let installedFromProjectFiles = false;
-  if (uvLockDir) {
-    (0, import_build_utils8.debug)('Found "uv.lock"');
-    if (pyprojectDir) {
-      const exportedReq = await exportRequirementsFromUv(pyprojectDir, uvPath, {
-        locked: true
-      });
-      await installRequirementsFile({
-        pythonPath: pythonVersion.pythonPath,
-        pipPath: pythonVersion.pipPath,
-        uvPath,
-        filePath: exportedReq,
-        workPath,
-        targetDir: vendorBaseDir,
-        meta
-      });
-      installedFromProjectFiles = true;
-    } else {
-      (0, import_build_utils8.debug)('Skipping uv export because "pyproject.toml" was not found');
-    }
-  } else if (pyprojectDir) {
-    (0, import_build_utils8.debug)('Found "pyproject.toml"');
-    if (hasReqLocal || hasReqGlobal) {
-      console.log(
-        "Detected both pyproject.toml and requirements.txt but no lockfile; using pyproject.toml"
+  } else {
+    let uvPath;
+    try {
+      uvPath = await getUvBinaryOrInstall(pythonVersion.pythonPath);
+      console.log(`Using uv at "${uvPath}"`);
+    } catch (err) {
+      console.log("Failed to install or locate uv");
+      throw new Error(
+        `uv is required for this project but failed to install: ${err instanceof Error ? err.message : String(err)}`
       );
     }
-    const exportedReq = await exportRequirementsFromUv(pyprojectDir, uvPath, {
-      locked: false
-    });
-    await installRequirementsFile({
-      pythonPath: pythonVersion.pythonPath,
-      pipPath: pythonVersion.pipPath,
-      uvPath,
-      filePath: exportedReq,
-      workPath,
-      targetDir: vendorBaseDir,
-      meta
-    });
-    installedFromProjectFiles = true;
-  } else if (pipfileLockDir || pipfileDir) {
-    (0, import_build_utils8.debug)(`Found ${pipfileLockDir ? '"Pipfile.lock"' : '"Pipfile"'}`);
-    if (hasReqLocal || hasReqGlobal) {
-      (0, import_build_utils8.debug)('Skipping Pipfile export because "requirements.txt" exists');
-    } else {
-      const exportedReq = await exportRequirementsFromPipfile({
-        pythonPath: pythonVersion.pythonPath,
-        pipPath: pythonVersion.pipPath,
-        uvPath,
-        projectDir: pipfileLockDir || pipfileDir,
-        meta
-      });
-      await installRequirementsFile({
-        pythonPath: pythonVersion.pythonPath,
-        pipPath: pythonVersion.pipPath,
-        uvPath,
-        filePath: exportedReq,
-        workPath,
-        targetDir: vendorBaseDir,
-        meta
-      });
-      installedFromProjectFiles = true;
-    }
-  }
-  if (!installedFromProjectFiles && fsFiles[requirementsTxt]) {
-    (0, import_build_utils8.debug)('Found local "requirements.txt"');
-    const requirementsTxtPath = fsFiles[requirementsTxt].fsPath;
-    await installRequirementsFile({
-      pythonPath: pythonVersion.pythonPath,
-      pipPath: pythonVersion.pipPath,
-      uvPath,
-      filePath: requirementsTxtPath,
+    const runtimeDependencies = framework === "flask" ? ["werkzeug>=1.0.1"] : ["werkzeug>=1.0.1", "uvicorn>=0.24"];
+    const { projectDir } = await ensureUvProject({
       workPath,
-      targetDir: vendorBaseDir,
-      meta
-    });
-  } else if (!installedFromProjectFiles && fsFiles["requirements.txt"]) {
-    (0, import_build_utils8.debug)('Found global "requirements.txt"');
-    const requirementsTxtPath = fsFiles["requirements.txt"].fsPath;
-    await installRequirementsFile({
+      entryDirectory,
+      fsFiles,
       pythonPath: pythonVersion.pythonPath,
       pipPath: pythonVersion.pipPath,
       uvPath,
-      filePath: requirementsTxtPath,
-      workPath,
-      targetDir: vendorBaseDir,
-      meta
+      venvPath,
+      meta,
+      runtimeDependencies
     });
-  }
-  if (pyprojectDir && repoRootPath) {
-    await installUvWorkspaceDependencies({
-      repoRootPath,
-      pyprojectDir,
-      pythonPath: pythonVersion.pythonPath,
-      pipPath: pythonVersion.pipPath,
+    await runUvSync({
       uvPath,
-      workPath,
-      vendorBaseDir,
-      meta
+      venvPath,
+      projectDir,
+      locked: true
     });
   }
-  const originalPyPath = (0, import_path6.join)(__dirname, "..", "vc_init.py");
+  const originalPyPath = (0, import_path5.join)(__dirname, "..", "vc_init.py");
   const originalHandlerPyContents = await readFile(originalPyPath, "utf8");
-  (0, import_build_utils8.debug)("Entrypoint is", entrypoint);
+  (0, import_build_utils7.debug)("Entrypoint is", entrypoint);
   const moduleName = entrypoint.replace(/\//g, ".").replace(/\.py$/i, "");
   const vendorDir = resolveVendorDir();
   const suffix = meta.isDev && !entrypoint.endsWith(".py") ? ".py" : "";
   const entrypointWithSuffix = `${entrypoint}${suffix}`;
-  (0, import_build_utils8.debug)("Entrypoint with suffix is", entrypointWithSuffix);
+  (0, import_build_utils7.debug)("Entrypoint with suffix is", entrypointWithSuffix);
   const handlerPyContents = originalHandlerPyContents.replace(/__VC_HANDLER_MODULE_NAME/g, moduleName).replace(/__VC_HANDLER_ENTRYPOINT/g, entrypointWithSuffix).replace(/__VC_HANDLER_VENDOR_DIR/g, vendorDir);
   const predefinedExcludes = [
     ".git/**",
@@ -4325,26 +4471,21 @@ var build = async ({
     cwd: workPath,
     ignore: config && typeof config.excludeFiles === "string" ? [...predefinedExcludes, config.excludeFiles] : predefinedExcludes
   };
-  const files = await (0, import_build_utils8.glob)("**", globOptions);
-  try {
-    const cachedVendorAbs = (0, import_path6.join)(vendorBaseDir, resolveVendorDir());
-    if (import_fs6.default.existsSync(cachedVendorAbs)) {
-      const vendorFiles = await (0, import_build_utils8.glob)("**", cachedVendorAbs, resolveVendorDir());
-      for (const [p, f] of Object.entries(vendorFiles)) {
-        files[p] = f;
-      }
-    }
-  } catch (err) {
-    console.log("Failed to include cached vendor directory");
-    throw err;
+  const files = await (0, import_build_utils7.glob)("**", globOptions);
+  const vendorFiles = await mirrorSitePackagesIntoVendor({
+    venvPath,
+    vendorDirName: vendorDir
+  });
+  for (const [p, f] of Object.entries(vendorFiles)) {
+    files[p] = f;
   }
   const handlerPyFilename = "vc__handler__python";
-  files[`${handlerPyFilename}.py`] = new import_build_utils8.FileBlob({ data: handlerPyContents });
+  files[`${handlerPyFilename}.py`] = new import_build_utils7.FileBlob({ data: handlerPyContents });
   if (config.framework === "fasthtml") {
     const { SESSKEY = "" } = process.env;
-    files[".sesskey"] = new import_build_utils8.FileBlob({ data: `"${SESSKEY}"` });
+    files[".sesskey"] = new import_build_utils7.FileBlob({ data: `"${SESSKEY}"` });
   }
-  const output = new import_build_utils8.Lambda({
+  const output = new import_build_utils7.Lambda({
     files,
     handler: `${handlerPyFilename}.vc_handler`,
     runtime: pythonVersion.runtime,
@@ -4380,7 +4521,7 @@ var defaultShouldServe = ({
   if (entrypoint === requestPath && hasProp(files, entrypoint)) {
     return true;
   }
-  const { dir, name } = (0, import_path6.parse)(entrypoint);
+  const { dir, name } = (0, import_path5.parse)(entrypoint);
   if (name === "index" && dir === requestPath && hasProp(files, entrypoint)) {
     return true;
   }