@vercel/python 25.0.0 → 25.1.2

package/dist/index.js

@@ -5032,7 +5032,7 @@ var import_fs20 = __toESM(require("fs"));
 var import_path21 = require("path");
 
 // src/package-versions.ts
-var VERCEL_RUNTIME_VERSION = "0.23.2";
+var VERCEL_RUNTIME_VERSION = "0.23.3";
 var VERCEL_WORKERS_VERSION = "0.0.25";
 
 // src/conditional-vendoring.ts
@@ -5366,12 +5366,13 @@ var import_execa4 = __toESM(require_execa());
 var import_fs5 = __toESM(require("fs"));
 var import_path6 = require("path");
 var import_build_utils6 = require("@vercel/build-utils");
-var import_python_analysis4 = require("@vercel/python-analysis");
+var import_python_analysis5 = require("@vercel/python-analysis");
 
 // src/utils.ts
 var import_fs3 = __toESM(require("fs"));
 var import_path4 = require("path");
 var import_build_utils3 = require("@vercel/build-utils");
+var import_python_analysis3 = require("@vercel/python-analysis");
 var import_execa3 = __toESM(require_execa());
 
 // src/uv.ts
@@ -5956,6 +5957,22 @@ async function ensureVenv({
     await (0, import_execa3.default)(pythonVersion.pythonPath, ["-m", "venv", venvPath]);
   }
 }
+var BUILD_ONLY_SEED_PACKAGES = ["pip"];
+async function getSeedPackagesMissingFromLock(uvLockPath) {
+  let lockedPackages;
+  try {
+    const content = await import_fs3.default.promises.readFile(uvLockPath, "utf8");
+    lockedPackages = new Set(
+      (0, import_python_analysis3.parseUvLock)(content, uvLockPath).packages.map(
+        (pkg) => (0, import_python_analysis3.normalizePackageName)(pkg.name)
+      )
+    );
+  } catch (err) {
+    (0, import_build_utils3.debug)(`could not read lock file "${uvLockPath}" for seed packages: ${err}`);
+    return [];
+  }
+  return BUILD_ONLY_SEED_PACKAGES.filter((name) => !lockedPackages.has(name));
+}
 function getVenvPythonBin(venvPath) {
   return (0, import_path4.join)(getVenvBinDir(venvPath), isWin2 ? "python.exe" : "python");
 }
@@ -5996,7 +6013,7 @@ async function runPyprojectScript(workPath, scriptNames, env, useUserVirtualEnv
 var import_path5 = require("path");
 var import_fs4 = require("fs");
 var import_build_utils5 = require("@vercel/build-utils");
-var import_python_analysis3 = require("@vercel/python-analysis");
+var import_python_analysis4 = require("@vercel/python-analysis");
 
 // src/platform-info.ts
 var import_os2 = __toESM(require("os"));
@@ -6207,7 +6224,7 @@ function resolvePythonVersion({
     const defaultBuild = toPythonBuild(defaultPv);
     const availableBuilds = getAvailablePythonBuilds();
     const allBuilds = getAllPythonBuilds();
-    const result = (0, import_python_analysis3.selectPythonVersion)({
+    const result = (0, import_python_analysis4.selectPythonVersion)({
       constraints,
       availableBuilds,
       allBuilds,
@@ -6266,7 +6283,7 @@ function resolvePythonVersion({
   }
   let pinVersionFilePath;
   const hasPythonVersionFile = pythonPackage.configs?.some(
-    (configSet) => configSet[import_python_analysis3.PythonConfigKind.PythonVersion] !== void 0
+    (configSet) => configSet[import_python_analysis4.PythonConfigKind.PythonVersion] !== void 0
   ) ?? false;
   if (!hasPythonVersionFile && pythonPackage.manifest && versionLessOrEqual(selection, defaultPv)) {
     if (autoUpgraded || !pythonPackage.manifest.origin && source?.endsWith("pyproject.toml")) {
@@ -6425,9 +6442,9 @@ async function discoverPackage({
   rootDir
 }) {
   try {
-    return await (0, import_python_analysis4.discoverPythonPackage)({ entrypointDir, rootDir });
+    return await (0, import_python_analysis5.discoverPythonPackage)({ entrypointDir, rootDir });
   } catch (error) {
-    if (error instanceof import_python_analysis4.PythonAnalysisError) {
+    if (error instanceof import_python_analysis5.PythonAnalysisError) {
       if (error.fileContent && (error.code.endsWith("_PARSE_ERROR") || error.code.endsWith("_VALIDATION_ERROR"))) {
         console.log(
           `Failed to parse "${error.path}". File content:
@@ -6449,10 +6466,10 @@ function detectInstallSource(pythonPackage, rootDir) {
   let manifestPath = null;
   const lockFile = pythonPackage.manifest?.lockFile ?? pythonPackage.workspaceLockFile;
   if (lockFile) {
-    if (lockFile.kind === import_python_analysis4.PythonLockFileKind.UvLock) {
+    if (lockFile.kind === import_python_analysis5.PythonLockFileKind.UvLock) {
       manifestType = "uv.lock";
       manifestPath = (0, import_path6.join)(rootDir, lockFile.path);
-    } else if (lockFile.kind === import_python_analysis4.PythonLockFileKind.PylockToml) {
+    } else if (lockFile.kind === import_python_analysis5.PythonLockFileKind.PylockToml) {
       manifestType = "pylock.toml";
       manifestPath = (0, import_path6.join)(rootDir, lockFile.path);
     }
@@ -6499,11 +6516,11 @@ async function ensureUvProject({
     projectDir = (0, import_path6.join)(rootDir, (0, import_path6.dirname)(manifest.path));
     pyprojectPath = (0, import_path6.join)(rootDir, manifest.path);
     const originKind = manifest.origin?.kind;
-    if (originKind === import_python_analysis4.PythonManifestConvertedKind.Pipfile) {
+    if (originKind === import_python_analysis5.PythonManifestConvertedKind.Pipfile) {
       console.log("Installing required dependencies from Pipfile...");
-    } else if (originKind === import_python_analysis4.PythonManifestConvertedKind.PipfileLock) {
+    } else if (originKind === import_python_analysis5.PythonManifestConvertedKind.PipfileLock) {
       console.log("Installing required dependencies from Pipfile.lock...");
-    } else if (originKind === import_python_analysis4.PythonManifestConvertedKind.RequirementsTxt || originKind === import_python_analysis4.PythonManifestConvertedKind.RequirementsIn) {
+    } else if (originKind === import_python_analysis5.PythonManifestConvertedKind.RequirementsTxt || originKind === import_python_analysis5.PythonManifestConvertedKind.RequirementsIn) {
       console.log(
         `Installing required dependencies from ${manifest.origin?.path ?? "requirements.txt"}...`
       );
@@ -6514,7 +6531,7 @@ async function ensureUvProject({
       if (manifest.data.project && pythonVersion !== void 0) {
         manifest.data.project["requires-python"] = `~=${pythonVersion}.0`;
       }
-      const content = (0, import_python_analysis4.stringifyManifest)(manifest.data);
+      const content = (0, import_python_analysis5.stringifyManifest)(manifest.data);
       pyprojectPath = (0, import_path6.join)(projectDir, "pyproject.toml");
       await import_fs5.default.promises.writeFile(pyprojectPath, content);
     }
@@ -6537,12 +6554,12 @@ async function ensureUvProject({
       "No Python manifest found; creating an empty pyproject.toml and uv.lock..."
     );
     const requiresPython = pythonVersion !== void 0 ? `~=${pythonVersion}.0` : `>=${DEFAULT_PYTHON_VERSION_STRING}`;
-    const minimalManifest = (0, import_python_analysis4.createMinimalManifest)({
+    const minimalManifest = (0, import_python_analysis5.createMinimalManifest)({
       name: "app",
       requiresPython,
       dependencies: []
     });
-    const content = (0, import_python_analysis4.stringifyManifest)(minimalManifest);
+    const content = (0, import_python_analysis5.stringifyManifest)(minimalManifest);
     await import_fs5.default.promises.writeFile(pyprojectPath, content);
     await restoreCachedLock(cachedLockPath, projectDir);
     await uv.lock({
@@ -6656,7 +6673,7 @@ var import_fs6 = __toESM(require("fs"));
 var import_util = require("util");
 var import_path7 = require("path");
 var import_build_utils7 = require("@vercel/build-utils");
-var import_python_analysis5 = require("@vercel/python-analysis");
+var import_python_analysis6 = require("@vercel/python-analysis");
 
 // src/large-functions.ts
 function isLargeFunctionsEnabled() {
@@ -6818,9 +6835,9 @@ smaller functions.`,
     }
     let lockFile;
     try {
-      lockFile = (0, import_python_analysis5.parseUvLock)(lockContent, relLockPath);
+      lockFile = (0, import_python_analysis6.parseUvLock)(lockContent, relLockPath);
     } catch (error) {
-      if (error instanceof import_python_analysis5.PythonAnalysisError) {
+      if (error instanceof import_python_analysis6.PythonAnalysisError) {
         if (error.fileContent) {
           (0, import_build_utils7.debug)(
             `Failed to parse "${error.path}". File content:
@@ -6841,7 +6858,7 @@ ${error.fileContent}`
         `Excluding project package "${this.projectName}" from runtime installation`
       );
     }
-    const classification = (0, import_python_analysis5.classifyPackages)({
+    const classification = (0, import_python_analysis6.classifyPackages)({
       lockFile,
       excludePackages
     });
@@ -6858,10 +6875,10 @@ ${error.fileContent}`
       );
     }
     const forceBundledSet = new Set(
-      forceBundledDueToWheels.map(import_python_analysis5.normalizePackageName)
+      forceBundledDueToWheels.map(import_python_analysis6.normalizePackageName)
     );
     const externalizablePublic = classification.publicPackages.filter(
-      (name) => !forceBundledSet.has((0, import_python_analysis5.normalizePackageName)(name))
+      (name) => !forceBundledSet.has((0, import_python_analysis6.normalizePackageName)(name))
     );
     if (externalizablePublic.length === 0) {
       if (largeFunctionsEnabled) {
@@ -6927,11 +6944,11 @@ To fix this, either:
       `Bundle size (${totalBundleSizeMB} MB) exceeds the standard size; optimizing dependencies.`
     );
     const externalizableSet = new Set(
-      externalizablePublic.map(import_python_analysis5.normalizePackageName)
+      externalizablePublic.map(import_python_analysis6.normalizePackageName)
     );
     const publicPackageSizes = new Map(
       [...packageSizes].filter(
-        ([name]) => externalizableSet.has((0, import_python_analysis5.normalizePackageName)(name))
+        ([name]) => externalizableSet.has((0, import_python_analysis6.normalizePackageName)(name))
       )
     );
     const { packingMode, bundledPublic } = planPublicPackagePacking({
@@ -6944,9 +6961,9 @@ To fix this, either:
         `bytecode-first packing disabled: the public package set exceeds the ephemeral install budget (${(EPHEMERAL_INSTALL_BUDGET_BYTES / (1024 * 1024)).toFixed(2)} MB); falling back to knapsack packing`
       );
     }
-    const bundledPublicSet = new Set(bundledPublic.map(import_python_analysis5.normalizePackageName));
+    const bundledPublicSet = new Set(bundledPublic.map(import_python_analysis6.normalizePackageName));
     const externalizedPublic = externalizablePublic.filter(
-      (name) => !bundledPublicSet.has((0, import_python_analysis5.normalizePackageName)(name))
+      (name) => !bundledPublicSet.has((0, import_python_analysis6.normalizePackageName)(name))
     );
     const allBundledPackages = [...alwaysBundled, ...bundledPublic];
     const selectedVendorFiles = await this.installedDistributions.mirrorPackagesIntoVendor({
@@ -7084,24 +7101,24 @@ functions.`,
       platform.archName
     );
     const relevantPackages = reachable ? publicPackageNames.filter(
-      (name) => reachable.has((0, import_python_analysis5.normalizePackageName)(name))
+      (name) => reachable.has((0, import_python_analysis6.normalizePackageName)(name))
     ) : publicPackageNames;
     if (relevantPackages.length < publicPackageNames.length) {
       (0, import_build_utils7.debug)(
         `Skipping wheel check for ${publicPackageNames.length - relevantPackages.length} package(s) not reachable on the target platform`
       );
     }
-    const publicSet = new Set(relevantPackages.map(import_python_analysis5.normalizePackageName));
+    const publicSet = new Set(relevantPackages.map(import_python_analysis6.normalizePackageName));
     const packageWheels = /* @__PURE__ */ new Map();
     for (const pkg of lockFile.packages) {
-      const normalized = (0, import_python_analysis5.normalizePackageName)(pkg.name);
+      const normalized = (0, import_python_analysis6.normalizePackageName)(pkg.name);
       if (publicSet.has(normalized) && pkg.wheels.length > 0) {
         packageWheels.set(normalized, pkg.wheels);
       }
     }
     const incompatible = [];
     for (const name of relevantPackages) {
-      const normalized = (0, import_python_analysis5.normalizePackageName)(name);
+      const normalized = (0, import_python_analysis6.normalizePackageName)(name);
       const wheels = packageWheels.get(normalized);
       if (!wheels || wheels.length === 0) {
         incompatible.push(name);
@@ -7113,7 +7130,7 @@ functions.`,
         if (!filename || !filename.endsWith(".whl"))
           continue;
         try {
-          const compatible = await (0, import_python_analysis5.isWheelCompatible)(
+          const compatible = await (0, import_python_analysis6.isWheelCompatible)(
             filename,
             this.pythonVersion.major,
             this.pythonVersion.minor,
@@ -7151,10 +7168,10 @@ functions.`,
 async function getPackagesReachableOnPlatform(lockFile, projectName, pythonMajor, pythonMinor, sysPlatform, platformMachine) {
   if (!projectName)
     return null;
-  const rootNormalized = (0, import_python_analysis5.normalizePackageName)(projectName);
+  const rootNormalized = (0, import_python_analysis6.normalizePackageName)(projectName);
   const packageMap = /* @__PURE__ */ new Map();
   for (const pkg of lockFile.packages) {
-    packageMap.set((0, import_python_analysis5.normalizePackageName)(pkg.name), pkg);
+    packageMap.set((0, import_python_analysis6.normalizePackageName)(pkg.name), pkg);
   }
   const rootPkg = packageMap.get(rootNormalized);
   if (!rootPkg)
@@ -7166,12 +7183,12 @@ async function getPackagesReachableOnPlatform(lockFile, projectName, pythonMajor
     if (!pkg.dependencies)
       return;
     for (const dep of pkg.dependencies) {
-      const normalized = (0, import_python_analysis5.normalizePackageName)(dep.name);
+      const normalized = (0, import_python_analysis6.normalizePackageName)(dep.name);
       if (visited.has(normalized))
         continue;
       if (dep.marker) {
         try {
-          const compatible = await (0, import_python_analysis5.evaluateMarker)(
+          const compatible = await (0, import_python_analysis6.evaluateMarker)(
             dep.marker,
             pythonMajor,
             pythonMinor,
@@ -7278,7 +7295,7 @@ function planPublicPackagePacking({
 // src/diagnostics.ts
 var import_fs7 = __toESM(require("fs"));
 var import_build_utils8 = require("@vercel/build-utils");
-var import_python_analysis6 = require("@vercel/python-analysis");
+var import_python_analysis7 = require("@vercel/python-analysis");
 function isDependencyGroupInclude(entry) {
   return typeof entry === "object" && "include-group" in entry;
 }
@@ -7371,13 +7388,13 @@ async function generateProjectManifest({
       allRawDeps.push({ dep, scope: "dev" });
     }
   }
-  const allParsed = await (0, import_python_analysis6.parsePep508)(allRawDeps.map((d) => d.dep));
+  const allParsed = await (0, import_python_analysis7.parsePep508)(allRawDeps.map((d) => d.dep));
   for (let i = 0; i < allRawDeps.length; i++) {
     const parsed = allParsed[i];
     if (!parsed)
       continue;
     const { dep, scope } = allRawDeps[i];
-    const normalized = (0, import_python_analysis6.normalizePackageName)(parsed.name);
+    const normalized = (0, import_python_analysis7.normalizePackageName)(parsed.name);
     let scopes = directScopesMap.get(normalized);
     if (!scopes) {
       scopes = /* @__PURE__ */ new Set();
@@ -7392,15 +7409,15 @@ async function generateProjectManifest({
   const transitiveEntries = [];
   {
     const content = await import_fs7.default.promises.readFile(uvLockPath, "utf-8");
-    const uvLock = (0, import_python_analysis6.parseUvLock)(content, uvLockPath);
+    const uvLock = (0, import_python_analysis7.parseUvLock)(content, uvLockPath);
     const projectName = project?.name;
     const excludeSet = new Set(
-      projectName ? [(0, import_python_analysis6.normalizePackageName)(projectName)] : []
+      projectName ? [(0, import_python_analysis7.normalizePackageName)(projectName)] : []
     );
     const lockMap = /* @__PURE__ */ new Map();
     const depGraph = /* @__PURE__ */ new Map();
     for (const pkg of uvLock.packages) {
-      const normalized = (0, import_python_analysis6.normalizePackageName)(pkg.name);
+      const normalized = (0, import_python_analysis7.normalizePackageName)(pkg.name);
       if (excludeSet.has(normalized))
         continue;
       if (pkg.source?.virtual)
@@ -7409,7 +7426,7 @@ async function generateProjectManifest({
       if (pkg.dependencies) {
         const deps = /* @__PURE__ */ new Set();
         for (const d of pkg.dependencies) {
-          deps.add((0, import_python_analysis6.normalizePackageName)(d.name));
+          deps.add((0, import_python_analysis7.normalizePackageName)(d.name));
         }
         depGraph.set(normalized, deps);
       }
@@ -7512,7 +7529,7 @@ var import_path8 = require("path");
 var import_build_utils9 = require("@vercel/build-utils");
 var import_build_utils10 = require("@vercel/build-utils");
 var import_build_utils11 = require("@vercel/build-utils");
-var import_python_analysis7 = require("@vercel/python-analysis");
+var import_python_analysis8 = require("@vercel/python-analysis");
 var PYTHON_ENTRYPOINT_FILENAMES = [
   "app",
   "index",
@@ -7595,7 +7612,7 @@ async function checkEntrypoint(workPath, relPath) {
   if (!await fileExists(absPath))
     return null;
   const content = await import_fs8.default.promises.readFile(absPath, "utf-8");
-  return (0, import_python_analysis7.findAppOrHandler)(content);
+  return (0, import_python_analysis8.findAppOrHandler)(content);
 }
 async function findPythonFilesRecursive(dir, rootDir) {
   const results = [];
@@ -7626,7 +7643,7 @@ async function findEntrypointCandidates(workPath) {
         (0, import_path8.join)(workPath, relPath),
         "utf-8"
       );
-      const varName = await (0, import_python_analysis7.findAppOrHandler)(content);
+      const varName = await (0, import_python_analysis8.findAppOrHandler)(content);
       if (varName) {
         candidates.push({ entrypoint: relPath, variableName: varName });
       }
@@ -7725,7 +7742,7 @@ async function findValidEntrypoint(workPath, candidates) {
     if (!await fileExists(absPath))
       continue;
     const content = await import_fs8.default.promises.readFile(absPath, "utf-8");
-    const varName = await (0, import_python_analysis7.findAppOrHandler)(content);
+    const varName = await (0, import_python_analysis8.findAppOrHandler)(content);
     if (varName) {
       (0, import_build_utils10.debug)(`Detected Python entrypoint: ${candidate} (variable: ${varName})`);
       return {
@@ -8120,7 +8137,7 @@ var import_util2 = require("util");
 var import_build_utils15 = require("@vercel/build-utils");
 var import_get_port = __toESM(require_get_port());
 var import_is_port_reachable = __toESM(require_is_port_reachable());
-var import_python_analysis8 = require("@vercel/python-analysis");
+var import_python_analysis9 = require("@vercel/python-analysis");
 
 // src/subscribers.ts
 var import_path12 = require("path");
@@ -9017,12 +9034,18 @@ async function syncDependencies({
   pythonBin,
   env,
   onStdout,
-  onStderr
+  onStderr,
+  onlyGroup,
+  activeVenv
 }) {
   const pythonPackage = await discoverPackage({
     entrypointDir: workPath,
     rootDir: workPath
   });
+  if (onlyGroup && !(onlyGroup in (pythonPackage.manifest?.data?.["dependency-groups"] ?? {}))) {
+    (0, import_build_utils15.debug)(`No "${onlyGroup}" dependency group found, skipping dependency sync`);
+    return;
+  }
   const installInfo = detectInstallSource(pythonPackage, workPath);
   const { manifestType } = installInfo;
   let { manifestPath } = installInfo;
@@ -9035,7 +9058,7 @@ async function syncDependencies({
     const syncDir = (0, import_path13.join)(workPath, ".vercel", "python", "sync");
     (0, import_fs13.mkdirSync)(syncDir, { recursive: true });
     const tempPyproject = (0, import_path13.join)(syncDir, "pyproject.toml");
-    const content = (0, import_python_analysis8.stringifyManifest)(manifest.data);
+    const content = (0, import_python_analysis9.stringifyManifest)(manifest.data);
     (0, import_fs13.writeFileSync)(tempPyproject, content, "utf8");
     manifestPath = tempPyproject;
     (0, import_build_utils15.debug)(
@@ -9064,6 +9087,8 @@ async function syncDependencies({
       uvPath,
       pythonBin,
       env,
+      onlyGroup,
+      activeVenv,
       onStdout: (data) => captured.push(["stdout", data]),
       onStderr: (data) => captured.push(["stderr", data])
     });
@@ -9083,6 +9108,8 @@ async function runSync({
   uvPath,
   pythonBin,
   env,
+  onlyGroup,
+  activeVenv,
   onStdout,
   onStderr
 }) {
@@ -9102,16 +9129,32 @@ async function runSync({
       }
       spawnCmd = uvPath;
       spawnArgs = ["sync"];
+      if (activeVenv) {
+        spawnArgs.push("--active");
+      }
+      if (onlyGroup) {
+        spawnArgs.push("--only-group", onlyGroup, "--no-install-project");
+      }
       break;
     }
     case "pylock.toml": {
       spawnCmd = pip.cmd;
-      spawnArgs = [...pip.prefix, "-r", manifestPath];
+      spawnArgs = [...pip.prefix];
+      if (onlyGroup) {
+        spawnArgs.push("--group", onlyGroup);
+      } else {
+        spawnArgs.push("-r", manifestPath);
+      }
       break;
     }
     case "pyproject.toml": {
       spawnCmd = pip.cmd;
-      spawnArgs = [...pip.prefix, projectDir];
+      spawnArgs = [...pip.prefix];
+      if (onlyGroup) {
+        spawnArgs.push("--group", onlyGroup);
+      } else {
+        spawnArgs.push(projectDir);
+      }
       break;
     }
     default:
@@ -9364,7 +9407,229 @@ async function getMultiServicePythonRunner(workPath, env, systemPython, uvPath)
   env.PATH = `${binDir}${import_path13.delimiter}${env.PATH || ""}`;
   return { command: pythonBin, args: [] };
 }
+async function getPersistentServer(serverKey, isStale) {
+  while (true) {
+    const existing = PERSISTENT_SERVERS.get(serverKey);
+    if (existing) {
+      if (isStale?.(existing)) {
+        killPersistentServer(serverKey);
+      } else {
+        return {
+          port: existing.port,
+          pid: existing.pid,
+          shutdown: async () => {
+          }
+        };
+      }
+    }
+    const pending = PENDING_STARTS.get(serverKey);
+    if (!pending)
+      return null;
+    await pending;
+  }
+}
+async function spawnPersistentServer({
+  serverKey,
+  workPath,
+  entry,
+  modulePath,
+  shimSubdir,
+  framework,
+  variableName,
+  extraPythonPath,
+  spawnCommand,
+  spawnArgsPrefix,
+  port: requestedPort,
+  env,
+  onStdout,
+  onStderr,
+  scheduleModule,
+  scheduleEnv
+}) {
+  const port = requestedPort ?? await (0, import_get_port.default)();
+  env.PORT = `${port}`;
+  if (entry) {
+    env.__VC_HANDLER_ENTRYPOINT_ABS = (0, import_path13.join)(workPath, entry);
+  }
+  const devShim = createDevShim(
+    workPath,
+    entry,
+    modulePath,
+    shimSubdir,
+    framework,
+    variableName
+  );
+  if (devShim) {
+    const shimDir = devShim.shimDir || (0, import_path13.join)(workPath, ".vercel", "python");
+    const runtimeDir = (0, import_path13.join)(workPath, ".vercel", "python");
+    const pathParts = shimDir !== runtimeDir ? [shimDir, runtimeDir] : [shimDir];
+    if (devShim.extraPythonPath) {
+      pathParts.push(devShim.extraPythonPath);
+    }
+    if (extraPythonPath) {
+      pathParts.push(extraPythonPath);
+    }
+    const existingPythonPath = env.PYTHONPATH || "";
+    if (existingPythonPath) {
+      pathParts.push(existingPythonPath);
+    }
+    env.PYTHONPATH = pathParts.join(import_path13.delimiter);
+  }
+  const moduleToRun = devShim?.module || modulePath;
+  const pythonArgs = ["-u", "-m", moduleToRun];
+  const argv = [...spawnArgsPrefix, ...pythonArgs];
+  (0, import_build_utils15.debug)(
+    `Starting Python dev server (${framework}): ${spawnCommand} ${argv.join(" ")} [PORT=${port}]`
+  );
+  if (process.stdout.columns) {
+    env.COLUMNS = `${process.stdout.columns}`;
+  }
+  const child = (0, import_child_process2.spawn)(spawnCommand, argv, {
+    cwd: workPath,
+    env,
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true
+  });
+  const stdoutLogListener = createLogListener(onStdout, process.stdout);
+  const stderrLogListener = createLogListener(onStderr, process.stderr);
+  child.stdout?.on("data", stdoutLogListener);
+  child.stderr?.on("data", stderrLogListener);
+  const childExited = new Promise((_resolve, reject) => {
+    child.once("error", (err) => {
+      reject(err);
+    });
+    child.once("exit", (code, signal) => {
+      reject(
+        new Error(
+          `Python dev server exited before binding (code=${code}, signal=${signal})`
+        )
+      );
+    });
+  });
+  await Promise.race([
+    checkForPort(port, DEV_SERVER_STARTUP_TIMEOUT),
+    childExited
+  ]);
+  const pid = child.pid;
+  PERSISTENT_SERVERS.set(serverKey, {
+    port,
+    pid,
+    child,
+    stdoutLogListener,
+    stderrLogListener,
+    scheduleModule,
+    scheduleEnv
+  });
+  return { port, pid };
+}
+var PROXY_DEPENDENCY_GROUP = "vercel.proxy";
+var startProxyDevServer = async ({
+  entrypoint,
+  workPath,
+  meta = {},
+  config,
+  onStdout,
+  onStderr
+}) => {
+  const handlerFunction = config?.handlerFunction;
+  if (typeof handlerFunction !== "string" || !handlerFunction) {
+    throw new Error(
+      'Python proxy dev server requires "config.handlerFunction" to be set'
+    );
+  }
+  const serverKey = `${workPath}::proxy::${entrypoint}`;
+  const existing = await getPersistentServer(serverKey);
+  if (existing) {
+    return existing;
+  }
+  if (!restoreWarnings)
+    restoreWarnings = silenceNodeWarnings();
+  installGlobalCleanupHandlers();
+  const proxySource = (0, import_fs13.readFileSync)((0, import_path13.join)(workPath, entrypoint), "utf8");
+  if (!await (0, import_python_analysis9.containsTopLevelCallable)(proxySource, handlerFunction)) {
+    throw new import_build_utils15.NowBuildError({
+      code: "PYTHON_HANDLER_NOT_FOUND",
+      message: `Handler function "${handlerFunction}" not found in ${entrypoint}. Ensure it is defined at the module's top level.`
+    });
+  }
+  const env = { ...process.env, ...meta.env || {} };
+  let resolveChildReady;
+  let rejectChildReady;
+  const childReady = new Promise(
+    (resolve4, reject) => {
+      resolveChildReady = resolve4;
+      rejectChildReady = reject;
+    }
+  );
+  PENDING_STARTS.set(serverKey, childReady);
+  try {
+    const { pythonPath: systemPython } = getDefaultPythonVersion(meta);
+    const uvPath = await findUvBinary(systemPython);
+    if (uvPath) {
+      checkUvBinaryVersion(uvPath);
+    }
+    const venvPath = (0, import_path13.join)(
+      workPath,
+      ".vercel",
+      "python",
+      PROXY_DEPENDENCY_GROUP,
+      ".venv"
+    );
+    await ensureVenv({
+      pythonVersion: { pythonPath: systemPython },
+      venvPath,
+      uvPath,
+      quiet: true
+    });
+    const pythonCmd = getVenvPythonBin(venvPath);
+    env.VIRTUAL_ENV = venvPath;
+    env.PATH = `${getVenvBinDir(venvPath)}${import_path13.delimiter}${env.PATH || ""}`;
+    await syncDependencies({
+      workPath,
+      uvPath,
+      pythonBin: pythonCmd,
+      env,
+      onStdout,
+      onStderr,
+      onlyGroup: PROXY_DEPENDENCY_GROUP,
+      activeVenv: true
+    });
+    await installInjectedDevPackage(
+      {
+        name: "vercel-runtime",
+        pinnedVersion: VERCEL_RUNTIME_VERSION,
+        envOverride: env.VERCEL_RUNTIME_PYTHON
+      },
+      { workPath, uvPath, pythonBin: pythonCmd, env, onStdout, onStderr }
+    );
+    const { port, pid } = await spawnPersistentServer({
+      serverKey,
+      workPath,
+      entry: entrypoint,
+      modulePath: entrypointToModule(entrypoint),
+      shimSubdir: PROXY_DEPENDENCY_GROUP,
+      framework: "python",
+      variableName: handlerFunction,
+      spawnCommand: pythonCmd,
+      spawnArgsPrefix: [],
+      env,
+      onStdout,
+      onStderr
+    });
+    resolveChildReady({ port, pid });
+    return { port, pid, shutdown: async () => {
+    } };
+  } catch (err) {
+    rejectChildReady(err);
+    throw err;
+  } finally {
+    PENDING_STARTS.delete(serverKey);
+  }
+};
 var startDevServer = async (opts) => {
+  if (opts.config?.middleware === true) {
+    return startProxyDevServer(opts);
+  }
   const {
     entrypoint: rawEntrypoint,
     workPath,
@@ -9382,24 +9647,12 @@ var startDevServer = async (opts) => {
   const scheduleEnv = scheduleFunction ? { ...env } : void 0;
   const serviceName = service?.name ?? (typeof meta.serviceName === "string" ? meta.serviceName : void 0);
   const serverKey = scheduleFunction ? `${workPath}::schedule::${scheduleFunction.outputPath}` : serviceName ? `${workPath}::${framework}::${serviceName}` : `${workPath}::${framework}`;
-  while (true) {
-    const existing = PERSISTENT_SERVERS.get(serverKey);
-    if (existing) {
-      if (scheduleFunction && (existing.scheduleModule !== scheduleModule || !(0, import_util2.isDeepStrictEqual)(existing.scheduleEnv, scheduleEnv))) {
-        killPersistentServer(serverKey);
-      } else {
-        return {
-          port: existing.port,
-          pid: existing.pid,
-          shutdown: async () => {
-          }
-        };
-      }
-    }
-    const pending = PENDING_STARTS.get(serverKey);
-    if (!pending)
-      break;
-    await pending;
+  const existing = await getPersistentServer(
+    serverKey,
+    (info) => !!scheduleFunction && (info.scheduleModule !== scheduleModule || !(0, import_util2.isDeepStrictEqual)(info.scheduleEnv, scheduleEnv))
+  );
+  if (existing) {
+    return existing;
   }
   if (!framework && !scheduleFunction) {
     return null;
@@ -9461,9 +9714,6 @@ var startDevServer = async (opts) => {
   }
   const { entrypoint: entry, variableName } = resolved;
   const modulePath = scheduleHandlerPath ? generatedPythonPathToModule(scheduleHandlerPath) : entrypointToModule(entry);
-  let childProcess = null;
-  let stdoutLogListener = null;
-  let stderrLogListener = null;
   let resolveChildReady;
   let rejectChildReady;
   const childReady = new Promise(
@@ -9713,82 +9963,25 @@ If you are using a virtual environment, activate it before running "vercel dev",
     if (crons?.length) {
       env.__VC_CRON_ROUTES = JSON.stringify(buildCronRouteTable(crons));
     }
-    const port = typeof meta.port === "number" ? meta.port : await (0, import_get_port.default)();
-    env.PORT = `${port}`;
-    if (entry) {
-      env.__VC_HANDLER_ENTRYPOINT_ABS = (0, import_path13.join)(workPath, entry);
-    }
-    const devShim = createDevShim(
+    const { port, pid } = await spawnPersistentServer({
+      serverKey,
       workPath,
       entry,
       modulePath,
-      scheduleHandlerPath ? scheduleHandlerPath.replace(/\.py$/, "") : serviceName && import_path13.posix.join("services", serviceName),
-      framework ?? "python",
-      variableName ?? ""
-    );
-    if (devShim) {
-      const shimDir = devShim.shimDir || (0, import_path13.join)(workPath, ".vercel", "python");
-      const runtimeDir = (0, import_path13.join)(workPath, ".vercel", "python");
-      const pathParts = shimDir !== runtimeDir ? [shimDir, runtimeDir] : [shimDir];
-      if (devShim.extraPythonPath) {
-        pathParts.push(devShim.extraPythonPath);
-      }
-      if (hookResult?.extraPythonPath) {
-        pathParts.push(hookResult.extraPythonPath);
-      }
-      const existingPythonPath = env.PYTHONPATH || "";
-      if (existingPythonPath) {
-        pathParts.push(existingPythonPath);
-      }
-      env.PYTHONPATH = pathParts.join(import_path13.delimiter);
-    }
-    const moduleToRun = devShim?.module || modulePath;
-    const pythonArgs = ["-u", "-m", moduleToRun];
-    const argv = [...spawnArgsPrefix, ...pythonArgs];
-    (0, import_build_utils15.debug)(
-      `Starting Python dev server (${framework}): ${spawnCommand} ${argv.join(" ")} [PORT=${port}]`
-    );
-    if (process.stdout.columns) {
-      env.COLUMNS = `${process.stdout.columns}`;
-    }
-    const child = (0, import_child_process2.spawn)(spawnCommand, argv, {
-      cwd: workPath,
+      shimSubdir: scheduleHandlerPath ? scheduleHandlerPath.replace(/\.py$/, "") : serviceName && import_path13.posix.join("services", serviceName),
+      framework: framework ?? "python",
+      variableName: variableName ?? "",
+      extraPythonPath: hookResult?.extraPythonPath,
+      spawnCommand,
+      spawnArgsPrefix,
+      port: typeof meta.port === "number" ? meta.port : void 0,
       env,
-      stdio: ["ignore", "pipe", "pipe"],
-      detached: true
-    });
-    childProcess = child;
-    stdoutLogListener = createLogListener(onStdout, process.stdout);
-    stderrLogListener = createLogListener(onStderr, process.stderr);
-    child.stdout?.on("data", stdoutLogListener);
-    child.stderr?.on("data", stderrLogListener);
-    const childExited = new Promise((_resolve, reject) => {
-      child.once("error", (err) => {
-        reject(err);
-      });
-      child.once("exit", (code, signal) => {
-        reject(
-          new Error(
-            `Python dev server exited before binding (code=${code}, signal=${signal})`
-          )
-        );
-      });
-    });
-    await Promise.race([
-      checkForPort(port, DEV_SERVER_STARTUP_TIMEOUT),
-      childExited
-    ]);
-    const pid = child.pid;
-    resolveChildReady({ port, pid });
-    PERSISTENT_SERVERS.set(serverKey, {
-      port,
-      pid,
-      child: childProcess,
-      stdoutLogListener,
-      stderrLogListener,
+      onStdout,
+      onStderr,
       scheduleModule,
       scheduleEnv
     });
+    resolveChildReady({ port, pid });
     const shutdown = async () => {
     };
     return { port, pid, shutdown, crons, queueSubscriptions };
@@ -9802,7 +9995,7 @@ If you are using a virtual environment, activate it before running "vercel dev",
 
 // src/quirks/index.ts
 var import_build_utils18 = require("@vercel/build-utils");
-var import_python_analysis10 = require("@vercel/python-analysis");
+var import_python_analysis11 = require("@vercel/python-analysis");
 
 // src/quirks/matplotlib.ts
 var matplotlibQuirk = {
@@ -9882,7 +10075,7 @@ var import_fs15 = __toESM(require("fs"));
 var import_path15 = require("path");
 var import_execa7 = __toESM(require_execa());
 var import_build_utils17 = require("@vercel/build-utils");
-var import_python_analysis9 = require("@vercel/python-analysis");
+var import_python_analysis10 = require("@vercel/python-analysis");
 function execErrorMessage(err) {
   if (err != null && typeof err === "object" && "stderr" in err) {
     const stderr = String(err.stderr);
@@ -10142,7 +10335,7 @@ echo "OpenSSL ${RUNTIME_OPENSSL_VERSION}.0 1 Jan 2024 (Library: OpenSSL ${RUNTIM
         (0, import_path15.join)(sitePackages, "prisma"),
         sitePackages
       );
-      const count = await (0, import_python_analysis9.extendDistRecord)(sitePackages, "prisma", allFiles);
+      const count = await (0, import_python_analysis10.extendDistRecord)(sitePackages, "prisma", allFiles);
       if (count > 0) {
         (0, import_build_utils17.debug)(`Appended ${count} entries to prisma RECORD`);
       }
@@ -10167,7 +10360,7 @@ var quirks = [litellmQuirk, prismaQuirk, matplotlibQuirk];
 function toposortQuirks(activated) {
   const nameToQuirk = /* @__PURE__ */ new Map();
   for (const q of activated) {
-    nameToQuirk.set((0, import_python_analysis10.normalizePackageName)(q.dependency), q);
+    nameToQuirk.set((0, import_python_analysis11.normalizePackageName)(q.dependency), q);
   }
   const adj = /* @__PURE__ */ new Map();
   const inDegree = /* @__PURE__ */ new Map();
@@ -10178,7 +10371,7 @@ function toposortQuirks(activated) {
   for (const q of activated) {
     if (q.runsBefore) {
       for (const dep of q.runsBefore) {
-        const target = nameToQuirk.get((0, import_python_analysis10.normalizePackageName)(dep));
+        const target = nameToQuirk.get((0, import_python_analysis11.normalizePackageName)(dep));
         if (target) {
           adj.get(q).add(target);
           inDegree.set(target, inDegree.get(target) + 1);
@@ -10187,7 +10380,7 @@ function toposortQuirks(activated) {
     }
     if (q.runsAfter) {
       for (const dep of q.runsAfter) {
-        const source = nameToQuirk.get((0, import_python_analysis10.normalizePackageName)(dep));
+        const source = nameToQuirk.get((0, import_python_analysis11.normalizePackageName)(dep));
         if (source) {
           adj.get(source).add(q);
           inDegree.set(q, inDegree.get(q) + 1);
@@ -10228,14 +10421,14 @@ async function runQuirks(ctx) {
   const installedNames = /* @__PURE__ */ new Set();
   const sitePackageDirs = await getVenvSitePackagesDirs(ctx.venvPath);
   for (const dir of sitePackageDirs) {
-    const distributions = await (0, import_python_analysis10.scanDistributions)(dir);
+    const distributions = await (0, import_python_analysis11.scanDistributions)(dir);
     for (const name of distributions.keys()) {
-      installedNames.add((0, import_python_analysis10.normalizePackageName)(name));
+      installedNames.add((0, import_python_analysis11.normalizePackageName)(name));
     }
   }
   const activated = quirks.filter((quirk) => {
     const installed = installedNames.has(
-      (0, import_python_analysis10.normalizePackageName)(quirk.dependency)
+      (0, import_python_analysis11.normalizePackageName)(quirk.dependency)
     );
     if (!installed) {
       (0, import_build_utils18.debug)(`Quirk "${quirk.dependency}": not installed, skipping`);
@@ -10449,7 +10642,7 @@ function fastapiStaticOptions(installedDistributions) {
 }
 
 // src/index.ts
-var import_python_analysis12 = require("@vercel/python-analysis");
+var import_python_analysis13 = require("@vercel/python-analysis");
 
 // src/bytecode-packing.ts
 function isBytecodeAnalysisDisabled() {
@@ -10749,7 +10942,7 @@ async function collectAppBytecodeFiles({
 var import_fs19 = __toESM(require("fs"));
 var import_path19 = require("path");
 var import_build_utils22 = require("@vercel/build-utils");
-var import_python_analysis11 = require("@vercel/python-analysis");
+var import_python_analysis12 = require("@vercel/python-analysis");
 var STRIP_BASENAMES = /* @__PURE__ */ new Set([
   "py.typed",
   "WHEEL",
@@ -10775,7 +10968,7 @@ function getDistributionFileGroups({
   if (includePackages?.length === 0) {
     return [];
   }
-  const includeSet = includePackages ? new Set(includePackages.map(import_python_analysis11.normalizePackageName)) : null;
+  const includeSet = includePackages ? new Set(includePackages.map(import_python_analysis12.normalizePackageName)) : null;
   const groups = [];
   for (const dir of sitePackageDirs) {
     const dirDistributions = distributions.get(dir);
@@ -10783,7 +10976,7 @@ function getDistributionFileGroups({
       continue;
     const sitePackagesDir = (0, import_path19.resolve)(dir);
     for (const [name, distribution] of dirDistributions) {
-      const packageName = (0, import_python_analysis11.normalizePackageName)(name);
+      const packageName = (0, import_python_analysis12.normalizePackageName)(name);
       if (includeSet && !includeSet.has(packageName))
         continue;
       const files = [];
@@ -10803,11 +10996,28 @@ function getDistributionFileGroups({
   }
   return groups;
 }
+function withoutPackages(distributions, packageNames) {
+  if (packageNames.length === 0) {
+    return distributions;
+  }
+  const excluded = new Set(packageNames.map(import_python_analysis12.normalizePackageName));
+  const filtered = /* @__PURE__ */ new Map();
+  for (const [dir, index] of distributions) {
+    filtered.set(
+      dir,
+      new Map(
+        [...index].filter(([name]) => !excluded.has((0, import_python_analysis12.normalizePackageName)(name)))
+      )
+    );
+  }
+  return filtered;
+}
 var InstalledPythonDistributions = class _InstalledPythonDistributions {
   static async load({
     venvPath,
     pythonMajor,
-    pythonMinor
+    pythonMinor,
+    excludePackages
   }) {
     const sitePackageDirs = await getVenvSitePackagesDirs(venvPath);
     const distributions = /* @__PURE__ */ new Map();
@@ -10817,18 +11027,22 @@ var InstalledPythonDistributions = class _InstalledPythonDistributions {
       } catch {
         continue;
       }
-      distributions.set(dir, await (0, import_python_analysis11.scanDistributions)(dir));
+      distributions.set(dir, await (0, import_python_analysis12.scanDistributions)(dir));
     }
     return new _InstalledPythonDistributions({
       sitePackageDirs,
       distributions,
       pythonMajor,
-      pythonMinor
+      pythonMinor,
+      excludePackages
     });
   }
   constructor(options) {
     this.sitePackageDirs = options.sitePackageDirs;
-    this.distributions = options.distributions;
+    this.distributions = withoutPackages(
+      options.distributions,
+      options.excludePackages ?? []
+    );
     this.pythonMajor = options.pythonMajor;
     this.pythonMinor = options.pythonMinor;
   }
@@ -10844,7 +11058,7 @@ var InstalledPythonDistributions = class _InstalledPythonDistributions {
    * normalization), or null when the package is not found in the venv.
    */
   getInstalledVersion(packageName) {
-    const target = (0, import_python_analysis11.normalizePackageName)(packageName);
+    const target = (0, import_python_analysis12.normalizePackageName)(packageName);
     for (const index of this.distributions.values()) {
       const dist = index.get(target);
       if (dist)
@@ -11691,7 +11905,10 @@ async function packFunctionBundle({
     const installedDistributions2 = await InstalledPythonDistributions.load({
       venvPath,
       pythonMajor: pythonVersion.major,
-      pythonMinor: pythonVersion.minor
+      pythonMinor: pythonVersion.minor,
+      // Without a uv.lock (custom install commands), a seeded package may
+      // be one the project installed on purpose, so it stays bundled.
+      excludePackages: uvLockPath ? await getSeedPackagesMissingFromLock(uvLockPath) : []
     });
     const depExternalizer = new PythonDependencyExternalizer({
       installedDistributions: installedDistributions2,
@@ -11752,7 +11969,7 @@ async function packFunctionBundle({
         try {
           const sitePackageDirs = installedDistributions2.getSitePackageDirs();
           const closure = await withTimeout(
-            (0, import_python_analysis12.collectImportClosure)(
+            (0, import_python_analysis13.collectImportClosure)(
               getImportClosureOptions({
                 workPath,
                 entrypoint,
@@ -12018,7 +12235,7 @@ async function buildProxyMiddleware({
     (0, import_path21.join)(workPath, entrypoint),
     "utf-8"
   );
-  if (!await (0, import_python_analysis12.containsTopLevelCallable)(proxySource, proxyHandlerFunction)) {
+  if (!await (0, import_python_analysis13.containsTopLevelCallable)(proxySource, proxyHandlerFunction)) {
     throw new import_build_utils24.NowBuildError({
       code: "PYTHON_HANDLER_NOT_FOUND",
       message: `Handler function "${proxyHandlerFunction}" not found in ${entrypoint}. Ensure it is defined at the module's top level.`
@@ -12051,7 +12268,9 @@ async function buildProxyMiddleware({
       // Install only the proxy's dependency group into the proxy venv;
       // the project itself is neither built nor installed.
       // If the group is absent the proxy has no extra deps — skip sync.
-      extraSyncParams: "vercel.proxy" in (pythonPackage?.manifest?.data?.["dependency-groups"] ?? {}) ? { onlyGroup: "vercel.proxy", noInstallProject: true } : void 0
+      // Group names are normalized on read, so `vercel.proxy` is keyed
+      // as `vercel-proxy`.
+      extraSyncParams: "vercel-proxy" in (pythonPackage?.manifest?.data?.["dependency-groups"] ?? {}) ? { onlyGroup: "vercel.proxy", noInstallProject: true } : void 0
     })
   );
   const pipPlatformArgs = target.uvPlatform ? ["--python-platform", target.uvPlatform] : [];
@@ -12592,7 +12811,7 @@ var build = async ({
     if (handlerFunction) {
       const entrypointPath = (0, import_path21.join)(workPath, entrypoint);
       const source = await import_fs20.default.promises.readFile(entrypointPath, "utf-8");
-      const found = await (0, import_python_analysis12.containsTopLevelCallable)(source, handlerFunction);
+      const found = await (0, import_python_analysis13.containsTopLevelCallable)(source, handlerFunction);
       if (!found) {
         throw new import_build_utils24.NowBuildError({
           code: "PYTHON_HANDLER_NOT_FOUND",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vercel/python",
-  "version": "25.0.0",
+  "version": "25.1.2",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -14,10 +14,10 @@
     "directory": "packages/python"
   },
   "dependencies": {
-    "@vercel/python-analysis": "0.14.0"
+    "@vercel/python-analysis": "0.15.0"
   },
   "peerDependencies": {
-    "@vercel/build-utils": "14.21.0"
+    "@vercel/build-utils": "14.21.2"
   },
   "devDependencies": {
     "@renovatebot/pep440": "4.2.1",
@@ -37,9 +37,9 @@
     "smol-toml": "1.5.2",
     "vitest": "4.1.10",
     "which": "3.0.0",
-    "@vercel/build-utils": "14.21.0",
+    "@vercel/build-utils": "14.21.2",
     "@vercel/error-utils": "2.2.1",
-    "@vercel/python-runtime": "0.23.2"
+    "@vercel/python-runtime": "0.23.3"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",