@vercel/python 25.1.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");
@@ -9041,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)(
@@ -9529,7 +9546,7 @@ var startProxyDevServer = async ({
     restoreWarnings = silenceNodeWarnings();
   installGlobalCleanupHandlers();
   const proxySource = (0, import_fs13.readFileSync)((0, import_path13.join)(workPath, entrypoint), "utf8");
-  if (!await (0, import_python_analysis8.containsTopLevelCallable)(proxySource, handlerFunction)) {
+  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.`
@@ -9978,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 = {
@@ -10058,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);
@@ -10318,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`);
       }
@@ -10343,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();
@@ -10354,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);
@@ -10363,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);
@@ -10404,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`);
@@ -10625,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() {
@@ -10925,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",
@@ -10951,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);
@@ -10959,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 = [];
@@ -10979,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();
@@ -10993,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;
   }
@@ -11020,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)
@@ -11867,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,
@@ -11928,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,
@@ -12194,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.`
@@ -12770,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.1.0",
+  "version": "25.1.2",
   "main": "./dist/index.js",
   "license": "Apache-2.0",
   "homepage": "https://vercel.com/docs/runtimes#official-runtimes/python",
@@ -17,7 +17,7 @@
     "@vercel/python-analysis": "0.15.0"
   },
   "peerDependencies": {
-    "@vercel/build-utils": "14.21.1"
+    "@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.2",
     "@vercel/error-utils": "2.2.1",
-    "@vercel/build-utils": "14.21.1",
-    "@vercel/python-runtime": "0.23.2"
+    "@vercel/python-runtime": "0.23.3"
   },
   "scripts": {
     "build": "node ../../utils/build-builder.mjs",