@vercel/python-analysis 0.9.1 → 0.10.1

package/dist/index.cjs

@@ -70,7 +70,9 @@ __export(src_exports, {
   extendDistRecord: () => extendDistRecord,
   getStringConstant: () => getStringConstant,
   isPrivatePackageSource: () => isPrivatePackageSource,
+  isWheelCompatible: () => isWheelCompatible,
   normalizePackageName: () => normalizePackageName2,
+  parsePep508: () => parsePep508,
   parseUvLock: () => parseUvLock,
   scanDistributions: () => scanDistributions,
   selectPython: () => selectPython,
@@ -83,6 +85,84 @@ module.exports = __toCommonJS(src_exports);
 var import_promises = require("fs/promises");
 var import_node_module = require("module");
 var import_node_path = require("path");
+
+// src/wasm/host-utils.ts
+var import_node_async_hooks = require("async_hooks");
+var import_posix = require("path/posix");
+var import_url = require("url");
+var readFileStorage = new import_node_async_hooks.AsyncLocalStorage();
+var WitResultError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.payload = message;
+  }
+};
+function createHostUtils() {
+  return {
+    readFile(path4) {
+      const ctx = readFileStorage.getStore();
+      if (ctx?.readFile) {
+        const relative2 = stripWorkingDir(path4, ctx.workingDir);
+        if (relative2 != null) {
+          const result = ctx.readFile(relative2);
+          if (result != null)
+            return result;
+        }
+      }
+      throw new WitResultError(`File not found: ${path4}`);
+    },
+    domainToAscii(domain) {
+      try {
+        if (/[:#?/@[\]%\\\t\n\r]/.test(domain)) {
+          throw new Error("domain contains invalid characters");
+        }
+        const url = new URL(`http://${domain}/`);
+        if (url.hostname === "" && domain !== "") {
+          throw new Error("domain resolved to empty hostname");
+        }
+        return url.hostname;
+      } catch {
+        throw { payload: `Invalid domain: ${domain}` };
+      }
+    },
+    domainToUnicode(domain) {
+      const result = (0, import_url.domainToUnicode)(domain);
+      if (result !== "" || domain === "") {
+        return [result, true];
+      }
+      return [domain, false];
+    },
+    nfcNormalize(s) {
+      return s.normalize("NFC");
+    },
+    nfdNormalize(s) {
+      return s.normalize("NFD");
+    },
+    nfkcNormalize(s) {
+      return s.normalize("NFKC");
+    },
+    nfkdNormalize(s) {
+      return s.normalize("NFKD");
+    }
+  };
+}
+function stripWorkingDir(path4, workingDir) {
+  const normalized = (0, import_posix.normalize)(path4);
+  if (!workingDir) {
+    return normalized;
+  }
+  const normalizedDir = (0, import_posix.normalize)(workingDir);
+  const prefix = normalizedDir.endsWith("/") ? normalizedDir : normalizedDir + "/";
+  if (normalized.startsWith(prefix)) {
+    return normalized.slice(prefix.length);
+  }
+  if (normalized === normalizedDir) {
+    return "";
+  }
+  return null;
+}
+
+// src/wasm/load.ts
 var WASI_SHIM_PATH = "@bytecodealliance/preview2-shim/instantiation";
 var WASM_MODULE_PATH = "#wasm/vercel_python_analysis.js";
 var wasmInstance = null;
@@ -110,7 +190,10 @@ async function importWasmModule() {
       const wasiShimModule = await import(WASI_SHIM_PATH);
       const WASIShim = wasiShimModule.WASIShim;
       const wasmModule = await import(WASM_MODULE_PATH);
-      const imports = new WASIShim().getImportObject();
+      const imports = {
+        ...new WASIShim().getImportObject(),
+        "vercel:python-analysis/host-utils": createHostUtils()
+      };
       const instance = await wasmModule.instantiate(getCoreModule, imports);
       wasmInstance = instance;
       return instance;
@@ -183,6 +266,41 @@ function mergeExtras(existing, additional) {
   }
   return result.size > 0 ? Array.from(result) : void 0;
 }
+function wasmEntryToRequirement(entry) {
+  const req = {
+    name: entry.name || ""
+  };
+  if (entry.versionSpec) {
+    req.version = entry.versionSpec;
+  }
+  if (entry.extras.length > 0) {
+    req.extras = entry.extras;
+  }
+  if (entry.markers) {
+    req.markers = entry.markers;
+  }
+  if (entry.url) {
+    req.url = entry.url;
+  }
+  return req;
+}
+async function parsePep508(depOrDeps) {
+  const wasm = await importWasmModule();
+  if (Array.isArray(depOrDeps)) {
+    return depOrDeps.map((dep) => {
+      try {
+        return wasmEntryToRequirement(wasm.parsePep508(dep));
+      } catch {
+        return null;
+      }
+    });
+  }
+  try {
+    return wasmEntryToRequirement(wasm.parsePep508(depOrDeps));
+  } catch {
+    return null;
+  }
+}
 
 // src/manifest/dist-metadata.ts
 async function readDistInfoFile(distInfoDir, filename) {
@@ -329,7 +447,7 @@ async function extendDistRecord(sitePackagesDir, packageName, paths) {
 }
 
 // src/manifest/package.ts
-var import_node_path6 = __toESM(require("path"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 var import_minimatch = require("minimatch");
 
 // src/util/config.ts
@@ -837,7 +955,8 @@ var uvIndexEntrySchema = import_zod3.z.object({
 var uvConfigSchema = import_zod3.z.object({
   sources: import_zod3.z.record(import_zod3.z.union([dependencySourceSchema, import_zod3.z.array(dependencySourceSchema)])).optional(),
   index: import_zod3.z.array(uvIndexEntrySchema).optional(),
-  workspace: uvConfigWorkspaceSchema.optional()
+  workspace: uvConfigWorkspaceSchema.optional(),
+  "dev-dependencies": import_zod3.z.array(import_zod3.z.string()).optional()
 });
 
 // src/manifest/pyproject/schema.zod.ts
@@ -878,7 +997,16 @@ var pyProjectProjectSchema = import_zod4.z.object({
   scripts: import_zod4.z.record(import_zod4.z.string()).optional(),
   entry_points: import_zod4.z.record(import_zod4.z.record(import_zod4.z.string())).optional()
 });
-var pyProjectDependencyGroupsSchema = import_zod4.z.record(import_zod4.z.array(import_zod4.z.string()));
+var dependencyGroupIncludeSchema = import_zod4.z.object({
+  "include-group": import_zod4.z.string()
+});
+var dependencyGroupEntrySchema = import_zod4.z.union([
+  import_zod4.z.string(),
+  dependencyGroupIncludeSchema
+]);
+var pyProjectDependencyGroupsSchema = import_zod4.z.record(
+  import_zod4.z.array(dependencyGroupEntrySchema)
+);
 var pyProjectToolSectionSchema = import_zod4.z.object({
   uv: uvConfigSchema.optional()
 });
@@ -902,356 +1030,98 @@ var PyProjectToolSectionSchema = pyProjectToolSectionSchema.passthrough();
 var PyProjectTomlSchema = pyProjectTomlSchema.passthrough();
 
 // src/manifest/requirements-txt-parser.ts
-var import_node_path5 = require("path");
-var import_pip_requirements_js = require("pip-requirements-js");
+var import_posix2 = require("path/posix");
 var PRIMARY_INDEX_NAME = "primary";
 var EXTRA_INDEX_PREFIX = "extra-";
 var FIND_LINKS_PREFIX = "find-links-";
-function parseGitUrl(url) {
-  if (!url.startsWith("git+")) {
-    return null;
-  }
-  let remaining = url.slice(4);
-  let egg;
-  const fragmentIdx = remaining.indexOf("#");
-  if (fragmentIdx !== -1) {
-    const fragment = remaining.slice(fragmentIdx + 1);
-    remaining = remaining.slice(0, fragmentIdx);
-    for (const part of fragment.split("&")) {
-      const [key, value] = part.split("=");
-      if (key === "egg" && value) {
-        egg = value;
-      }
-    }
-  }
-  let ref;
-  const lastSlashIdx = remaining.lastIndexOf("/");
-  const atIdx = remaining.indexOf("@", lastSlashIdx > 0 ? lastSlashIdx : 0);
-  if (atIdx !== -1 && atIdx > remaining.indexOf("://")) {
-    ref = remaining.slice(atIdx + 1);
-    remaining = remaining.slice(0, atIdx);
+async function parseWithWasm(content, readFile4, workingDir) {
+  const wasm = await importWasmModule();
+  const resolvedDir = workingDir ?? "/";
+  if (readFile4) {
+    return readFileStorage.run(
+      { readFile: readFile4, workingDir: resolvedDir },
+      () => wasm.parseRequirementsTxt(content, resolvedDir, void 0)
+    );
   }
-  return {
-    url: remaining,
-    ref,
-    egg
-  };
+  return wasm.parseRequirementsTxt(content, workingDir ?? void 0, void 0);
 }
-function isGitUrl(url) {
-  return url.startsWith("git+");
-}
-function extractPipArguments(fileContent) {
-  const options = {
-    requirementFiles: [],
-    constraintFiles: [],
-    extraIndexUrls: []
-  };
-  const lines = fileContent.split(/\r?\n/);
-  const cleanedLines = [];
-  const pathRequirements = [];
-  const editableRequirements = [];
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const trimmed = line.trim();
-    if (trimmed === "" || trimmed.startsWith("#")) {
-      cleanedLines.push(line);
-      continue;
-    }
-    let fullLine = trimmed;
-    let linesConsumed = 0;
-    while (fullLine.endsWith("\\") && i + linesConsumed + 1 < lines.length) {
-      linesConsumed++;
-      fullLine = fullLine.slice(0, -1) + lines[i + linesConsumed].trim();
-    }
-    const extracted = tryExtractPipArgument(fullLine, options);
-    if (extracted === true) {
-      i += linesConsumed;
-    } else if (typeof extracted === "object" && extracted.editable) {
-      editableRequirements.push(extracted.editable);
-      i += linesConsumed;
-    } else {
-      if (/^-[a-zA-Z]/.test(fullLine) && !fullLine.startsWith("-r") && !fullLine.startsWith("-c")) {
-        i += linesConsumed;
-        continue;
-      }
-      const strippedLine = stripInlineHashes(fullLine);
-      const effectiveLine = (strippedLine !== fullLine ? strippedLine : fullLine).trim();
-      if (isPathOrUrlRequirement(effectiveLine)) {
-        pathRequirements.push(effectiveLine);
-      } else if (strippedLine !== fullLine) {
-        cleanedLines.push(strippedLine);
-      } else {
-        cleanedLines.push(line);
-        for (let j = 1; j <= linesConsumed; j++) {
-          cleanedLines.push(lines[i + j]);
-        }
-      }
-      i += linesConsumed;
+function wasmEntryToNormalized(entry, editable) {
+  let name = entry.name || "";
+  if (!name && entry.url) {
+    const urlPath = entry.url.replace(/^file:\/\//, "");
+    const basename = urlPath.replace(/\/$/, "").split("/").pop();
+    if (basename && !basename.includes(".")) {
+      name = basename;
     }
   }
-  return {
-    cleanedContent: cleanedLines.join("\n"),
-    options,
-    pathRequirements,
-    editableRequirements
+  const req = {
+    name
   };
-}
-function tryExtractPipArgument(line, options) {
-  if (line.startsWith("--requirement")) {
-    const path4 = extractArgValue(line, "--requirement");
-    if (path4) {
-      options.requirementFiles.push(path4);
-      return true;
-    }
+  if (entry.versionSpec) {
+    req.version = entry.versionSpec;
   }
-  if (line.startsWith("--constraint")) {
-    const path4 = extractArgValue(line, "--constraint");
-    if (path4) {
-      options.constraintFiles.push(path4);
-      return true;
-    }
+  if (entry.extras.length > 0) {
+    req.extras = entry.extras;
   }
-  if (line.startsWith("--index-url")) {
-    const url = extractArgValue(line, "--index-url");
-    if (url) {
-      options.indexUrl = url;
-      return true;
-    }
-  }
-  if (line.startsWith("-i ") || line === "-i") {
-    const match = line.match(/^-i\s+(\S+)/);
-    if (match) {
-      options.indexUrl = match[1];
-      return true;
-    }
-  }
-  if (line.startsWith("--extra-index-url")) {
-    const url = extractArgValue(line, "--extra-index-url");
-    if (url) {
-      options.extraIndexUrls.push(url);
-      return true;
-    }
+  if (entry.markers) {
+    req.markers = entry.markers;
   }
-  if (line.startsWith("--editable")) {
-    const path4 = extractArgValue(line, "--editable");
-    if (path4) {
-      return { editable: path4 };
-    }
-  }
-  if (line.startsWith("-e ") || line.startsWith("-e	")) {
-    const path4 = line.slice(2).trim();
-    if (path4) {
-      return { editable: path4 };
-    }
-  }
-  if (line.startsWith("--find-links")) {
-    const url = extractArgValue(line, "--find-links");
-    if (url) {
-      if (!options.findLinks)
-        options.findLinks = [];
-      options.findLinks.push(url);
-      return true;
-    }
-  }
-  if (line.startsWith("-f ") || line.startsWith("-f	")) {
-    const match = line.match(/^-f\s+(\S+)/);
-    if (match) {
-      if (!options.findLinks)
-        options.findLinks = [];
-      options.findLinks.push(match[1]);
-      return true;
-    }
-  }
-  if (line === "--no-index" || line.startsWith("--no-index ")) {
-    options.noIndex = true;
-    return true;
-  }
-  if (line.startsWith("--no-binary") || line.startsWith("--only-binary")) {
-    return true;
-  }
-  if (line.startsWith("--")) {
-    return true;
-  }
-  return false;
-}
-function stripInlineHashes(line) {
-  return line.replace(/\s+--hash=\S+/g, "").trim();
-}
-function extractInlineHashes(line) {
-  const hashes = [];
-  const hashRegex = /--hash=(\S+)/g;
-  let match;
-  while ((match = hashRegex.exec(line)) != null) {
-    hashes.push(match[1]);
-  }
-  return hashes;
-}
-function extractArgValue(line, option) {
-  let value = null;
-  if (line.startsWith(`${option}=`)) {
-    value = line.slice(option.length + 1).trim();
-  } else if (line.startsWith(`${option} `) || line.startsWith(`${option}	`)) {
-    value = line.slice(option.length).trim();
-  }
-  if (!value)
-    return null;
-  const commentIdx = value.indexOf(" #");
-  if (commentIdx !== -1) {
-    value = value.slice(0, commentIdx).trim();
-  }
-  return value || null;
-}
-function isPathOrUrlRequirement(line) {
-  if (line.startsWith("./") || line.startsWith("../"))
-    return true;
-  if (line.startsWith("/"))
-    return true;
-  if (line.startsWith("~/"))
-    return true;
-  if (/^(https?|ftp|file):\/\//i.test(line))
-    return true;
-  if (isBareArchiveFilename(line))
-    return true;
-  return false;
-}
-function isBareArchiveFilename(line) {
-  if (line.includes(" @ "))
-    return false;
-  let check = line;
-  const commentIdx = check.indexOf(" #");
-  if (commentIdx !== -1)
-    check = check.slice(0, commentIdx);
-  const markerIdx = check.indexOf(" ;");
-  if (markerIdx !== -1)
-    check = check.slice(0, markerIdx);
-  const extrasIdx = check.indexOf("[");
-  if (extrasIdx !== -1)
-    check = check.slice(0, extrasIdx);
-  check = check.trim();
-  return /\.(whl|tar\.gz|tar\.bz2|tar\.xz|zip)$/i.test(check);
-}
-function parseWheelFilename(filename) {
-  if (!filename.endsWith(".whl"))
-    return null;
-  const stem = filename.slice(0, -4);
-  const parts = stem.split("-");
-  if (parts.length < 5 || parts.length > 6)
-    return null;
-  const name = parts[0];
-  const version = parts[1];
-  if (!name || !version)
-    return null;
-  return {
-    name: name.replace(/_/g, "-"),
-    version
-  };
-}
-function parseSdistFilename(filename) {
-  let stem = filename;
-  for (const ext of [".tar.gz", ".tar.bz2", ".tar.xz", ".zip"]) {
-    if (stem.endsWith(ext)) {
-      stem = stem.slice(0, -ext.length);
-      break;
-    }
-  }
-  if (stem === filename)
-    return null;
-  const parts = stem.split("-");
-  let versionIdx = -1;
-  for (let i = 1; i < parts.length; i++) {
-    if (/^\d/.test(parts[i])) {
-      versionIdx = i;
-      break;
+  if (entry.vcs) {
+    const source = {
+      git: entry.vcs.url
+    };
+    if (entry.vcs.rev) {
+      source.rev = entry.vcs.rev;
     }
-  }
-  if (versionIdx === -1)
-    return null;
-  return {
-    name: parts.slice(0, versionIdx).join("-"),
-    version: parts.slice(versionIdx).join("-")
-  };
-}
-function normalizePathRequirement(rawLine) {
-  let line = rawLine;
-  const commentIdx = line.indexOf(" #");
-  if (commentIdx !== -1) {
-    line = line.slice(0, commentIdx).trim();
-  }
-  let markers;
-  const markerIdx = line.indexOf(" ;");
-  if (markerIdx !== -1) {
-    markers = line.slice(markerIdx + 2).trim();
-    line = line.slice(0, markerIdx).trim();
-  }
-  let extras;
-  const extrasMatch = line.match(/\[([^\]]+)\]$/);
-  if (extrasMatch) {
-    extras = extrasMatch[1].split(",").map((e) => e.trim());
-    line = line.slice(0, extrasMatch.index).trim();
-  }
-  const isUrl = /^(https?|ftp|file):\/\//i.test(line);
-  let filename;
-  if (isUrl) {
-    try {
-      const url = new URL(line);
-      filename = url.pathname.split("/").pop() || "";
-    } catch {
-      return null;
+    if (editable) {
+      source.editable = true;
     }
-  } else {
-    const cleanPath = line.replace(/\/+$/, "");
-    filename = cleanPath.split("/").pop() || "";
-  }
-  if (!filename)
-    return null;
-  let name;
-  let version;
-  const wheelParsed = parseWheelFilename(filename);
-  if (wheelParsed) {
-    name = wheelParsed.name;
-    version = wheelParsed.version;
+    req.source = source;
   }
-  if (!name) {
-    const sdistParsed = parseSdistFilename(filename);
-    if (sdistParsed) {
-      name = sdistParsed.name;
-      version = sdistParsed.version;
+  if (entry.url) {
+    if (entry.url.startsWith("file://") && !entry.vcs) {
+      const given = entry.givenUrl ?? entry.url;
+      const path4 = given.startsWith("file://") ? given.slice("file://".length) : given;
+      req.source = { path: path4, ...editable ? { editable: true } : {} };
+    } else {
+      req.url = entry.url;
     }
   }
-  if (!name) {
-    name = filename.replace(/[-_.]+/g, "-").toLowerCase();
-  }
-  if (!name)
-    return null;
-  const req = { name };
-  if (version) {
-    req.version = `==${version}`;
-  }
-  if (extras && extras.length > 0) {
-    req.extras = extras;
-  }
-  if (markers) {
-    req.markers = markers;
-  }
-  if (isUrl) {
-    req.url = line;
-  } else {
-    req.source = { path: line };
+  if (entry.hashes.length > 0) {
+    req.hashes = entry.hashes;
   }
   return req;
 }
-function convertRequirementsToPyprojectToml(fileContent, readFile4) {
+function rebasePath(p, workingDir, packageRoot) {
+  if (!workingDir || !packageRoot || workingDir === packageRoot)
+    return p;
+  if ((0, import_posix2.isAbsolute)(p))
+    return p;
+  const abs = (0, import_posix2.join)(workingDir, p);
+  const rel = (0, import_posix2.relative)(packageRoot, abs);
+  if ((0, import_posix2.isAbsolute)(rel))
+    return rel;
+  if (rel.startsWith(".."))
+    return rel;
+  return "./" + rel;
+}
+async function convertRequirementsToPyprojectToml(fileContent, options) {
   const pyproject = {};
-  const parsed = parseRequirementsFile(fileContent, readFile4);
+  const parsed = await parseRequirementsFile(fileContent, options);
   const deps = [];
   const sources = {};
+  const { workingDir, packageRoot } = options ?? {};
   for (const req of parsed.requirements) {
     deps.push(formatPep508(req));
     if (req.source) {
+      const source = { ...req.source };
+      if (source.path) {
+        source.path = rebasePath(source.path, workingDir, packageRoot);
+      }
       if (Object.prototype.hasOwnProperty.call(sources, req.name)) {
-        sources[req.name].push(req.source);
+        sources[req.name].push(source);
       } else {
-        sources[req.name] = [req.source];
+        sources[req.name] = [source];
       }
     }
   }
@@ -1301,217 +1171,39 @@ function buildIndexEntries(pipOptions) {
   }
   return indexes;
 }
-function parseRequirementsFile(fileContent, readFile4) {
-  const visited = /* @__PURE__ */ new Set();
-  return parseRequirementsFileInternal(fileContent, readFile4, visited);
+async function parseRequirementsFile(fileContent, options) {
+  const wasmResult = await parseWithWasm(
+    fileContent,
+    options?.readFile,
+    options?.workingDir
+  );
+  return processWasmResult(wasmResult);
 }
-function parseRequirementsFileInternal(fileContent, readFile4, visited) {
-  const { cleanedContent, options, pathRequirements, editableRequirements } = extractPipArguments(fileContent);
-  const hashMap = buildHashMap(fileContent);
-  const requirements = (0, import_pip_requirements_js.parsePipRequirementsFile)(cleanedContent);
+function processWasmResult(wasmResult) {
   const normalized = [];
-  const mergedOptions = {
-    requirementFiles: [...options.requirementFiles],
-    constraintFiles: [...options.constraintFiles],
-    indexUrl: options.indexUrl,
-    extraIndexUrls: [...options.extraIndexUrls],
-    findLinks: options.findLinks ? [...options.findLinks] : void 0,
-    noIndex: options.noIndex
+  for (const entry of wasmResult.requirements) {
+    normalized.push(wasmEntryToNormalized(entry, false));
+  }
+  for (const entry of wasmResult.editables) {
+    const norm = wasmEntryToNormalized(entry, true);
+    if (!norm.source && !entry.vcs) {
+      norm.source = { path: entry.pep508, editable: true };
+    } else if (norm.source && !norm.source.editable) {
+      norm.source.editable = true;
+    }
+    normalized.push(norm);
+  }
+  const pipOptions = {
+    indexUrl: wasmResult.indexUrl || void 0,
+    extraIndexUrls: [...wasmResult.extraIndexUrls],
+    findLinks: wasmResult.findLinks.length > 0 ? [...wasmResult.findLinks] : void 0,
+    noIndex: wasmResult.noIndex || void 0
   };
-  for (const req of requirements) {
-    if (req.type === "RequirementsFile") {
-      mergedOptions.requirementFiles.push(req.path);
-      continue;
-    }
-    if (req.type === "ConstraintsFile") {
-      mergedOptions.constraintFiles.push(req.path);
-      continue;
-    }
-    const norm = normalizeRequirement(req);
-    if (norm != null) {
-      const hashes = hashMap.get(norm.name.toLowerCase());
-      if (hashes && hashes.length > 0) {
-        norm.hashes = hashes;
-      }
-      normalized.push(norm);
-    }
-  }
-  for (const rawPath of pathRequirements) {
-    const norm = normalizePathRequirement(rawPath);
-    if (norm != null) {
-      normalized.push(norm);
-    }
-  }
-  for (const rawPath of editableRequirements) {
-    const norm = normalizePathRequirement(rawPath);
-    if (norm != null) {
-      if (norm.source) {
-        norm.source.editable = true;
-      } else {
-        norm.source = { path: rawPath, editable: true };
-      }
-      normalized.push(norm);
-    }
-  }
-  if (readFile4) {
-    for (const refPath of mergedOptions.requirementFiles) {
-      const refPathKey = (0, import_node_path5.normalize)(refPath);
-      if (visited.has(refPathKey)) {
-        continue;
-      }
-      visited.add(refPathKey);
-      const refContent = readFile4(refPath);
-      if (refContent != null) {
-        const refParsed = parseRequirementsFileInternal(
-          refContent,
-          readFile4,
-          visited
-        );
-        const existingNames = new Set(
-          normalized.map((r) => r.name.toLowerCase())
-        );
-        for (const req of refParsed.requirements) {
-          if (!existingNames.has(req.name.toLowerCase())) {
-            normalized.push(req);
-            existingNames.add(req.name.toLowerCase());
-          }
-        }
-        if (refParsed.pipOptions.indexUrl) {
-          mergedOptions.indexUrl = refParsed.pipOptions.indexUrl;
-        }
-        for (const url of refParsed.pipOptions.extraIndexUrls) {
-          if (!mergedOptions.extraIndexUrls.includes(url)) {
-            mergedOptions.extraIndexUrls.push(url);
-          }
-        }
-        for (const constraintPath of refParsed.pipOptions.constraintFiles) {
-          if (!mergedOptions.constraintFiles.includes(constraintPath)) {
-            mergedOptions.constraintFiles.push(constraintPath);
-          }
-        }
-        if (refParsed.pipOptions.findLinks) {
-          if (!mergedOptions.findLinks)
-            mergedOptions.findLinks = [];
-          for (const fl of refParsed.pipOptions.findLinks) {
-            if (!mergedOptions.findLinks.includes(fl)) {
-              mergedOptions.findLinks.push(fl);
-            }
-          }
-        }
-        if (refParsed.pipOptions.noIndex) {
-          mergedOptions.noIndex = true;
-        }
-      }
-    }
-  }
   return {
     requirements: normalized,
-    pipOptions: mergedOptions
+    pipOptions
   };
 }
-function buildHashMap(fileContent) {
-  const hashMap = /* @__PURE__ */ new Map();
-  const lines = fileContent.split(/\r?\n/);
-  for (let i = 0; i < lines.length; i++) {
-    let line = lines[i].trim();
-    if (line === "" || line.startsWith("#") || line.startsWith("-")) {
-      continue;
-    }
-    while (line.endsWith("\\") && i + 1 < lines.length) {
-      i++;
-      line = line.slice(0, -1) + lines[i].trim();
-    }
-    const hashes = extractInlineHashes(line);
-    if (hashes.length === 0) {
-      continue;
-    }
-    const packageMatch = line.match(/^([a-zA-Z0-9][-a-zA-Z0-9._]*)/);
-    if (packageMatch) {
-      const packageName = packageMatch[1].toLowerCase();
-      hashMap.set(packageName, hashes);
-    }
-  }
-  return hashMap;
-}
-function normalizeRequirement(req) {
-  if (req.type === "RequirementsFile" || req.type === "ConstraintsFile") {
-    return null;
-  }
-  if (req.type === "ProjectURL") {
-    return normalizeProjectURLRequirement(req);
-  }
-  if (req.type === "ProjectName") {
-    return normalizeProjectNameRequirement(req);
-  }
-  return null;
-}
-function normalizeProjectNameRequirement(req) {
-  const normalized = {
-    name: req.name
-  };
-  if (req.extras && req.extras.length > 0) {
-    normalized.extras = req.extras;
-  }
-  if (req.versionSpec && req.versionSpec.length > 0) {
-    normalized.version = req.versionSpec.map((spec) => `${spec.operator}${spec.version}`).join(",");
-  }
-  if (req.environmentMarkerTree) {
-    normalized.markers = formatEnvironmentMarkers(req.environmentMarkerTree);
-  }
-  return normalized;
-}
-function normalizeProjectURLRequirement(req) {
-  const normalized = {
-    name: req.name
-  };
-  if (req.extras && req.extras.length > 0) {
-    normalized.extras = req.extras;
-  }
-  if (req.environmentMarkerTree) {
-    normalized.markers = formatEnvironmentMarkers(req.environmentMarkerTree);
-  }
-  if (isGitUrl(req.url)) {
-    const parsed = parseGitUrl(req.url);
-    if (parsed) {
-      const source = {
-        git: parsed.url
-      };
-      if (parsed.ref) {
-        source.rev = parsed.ref;
-      }
-      if (parsed.editable) {
-        source.editable = true;
-      }
-      normalized.source = source;
-    }
-  }
-  normalized.url = req.url;
-  return normalized;
-}
-function formatEnvironmentMarkers(marker) {
-  if (isEnvironmentMarkerNode(marker)) {
-    const left = formatEnvironmentMarkers(marker.left);
-    const right = formatEnvironmentMarkers(marker.right);
-    return `(${left}) ${marker.operator} (${right})`;
-  }
-  const leaf = marker;
-  const leftStr = formatMarkerValue(leaf.left);
-  const rightStr = formatMarkerValue(leaf.right);
-  return `${leftStr} ${leaf.operator} ${rightStr}`;
-}
-function isEnvironmentMarkerNode(marker) {
-  if (typeof marker !== "object" || marker == null) {
-    return false;
-  }
-  const op = marker.operator;
-  return op === "and" || op === "or";
-}
-function formatMarkerValue(value) {
-  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-    return value;
-  }
-  return value;
-}
 
 // src/manifest/uv-config/schema.ts
 var UvConfigWorkspaceSchema = uvConfigWorkspaceSchema.passthrough();
@@ -1907,7 +1599,7 @@ async function discoverPythonPackage({
 }) {
   const entrypointPath = normalizePath(entrypointDir);
   const rootPath = normalizePath(rootDir);
-  let prefix = import_node_path6.default.relative(rootPath, entrypointPath);
+  let prefix = import_node_path5.default.relative(rootPath, entrypointPath);
   if (prefix.startsWith("..")) {
     throw new PythonAnalysisError({
       message: "Entrypoint directory outside of repository root",
@@ -1931,7 +1623,7 @@ async function discoverPythonPackage({
     if (prefix === "" || prefix === ".") {
       break;
     }
-    prefix = import_node_path6.default.dirname(prefix);
+    prefix = import_node_path5.default.dirname(prefix);
   }
   let entrypointManifest;
   let workspaceManifest;
@@ -1953,8 +1645,8 @@ async function discoverPythonPackage({
     configs = configs.filter(
       (config) => Object.values(config).some(
         (cfg) => cfg !== void 0 && isSubpath(
-          import_node_path6.default.dirname(cfg.path),
-          import_node_path6.default.dirname(entrypointWorkspaceManifest.path)
+          import_node_path5.default.dirname(cfg.path),
+          import_node_path5.default.dirname(entrypointWorkspaceManifest.path)
         )
       )
     );
@@ -1981,7 +1673,8 @@ function computeRequiresPython(manifest, workspaceManifest, configs) {
       constraints.push({
         request: pythonVersionConfig.data,
         source: pythonVersionConfig.path,
-        prettySource: pythonVersionConfig.path
+        prettySource: pythonVersionConfig.path,
+        specifier: pythonVersionConfig.specifier
       });
       hasPythonVersionFile = true;
       break;
@@ -1996,7 +1689,8 @@ function computeRequiresPython(manifest, workspaceManifest, configs) {
         constraints.push({
           request: [request],
           source: manifest.path,
-          prettySource: `"requires-python" key in ${manifest.path}`
+          prettySource: `"requires-python" key in ${manifest.path}`,
+          specifier: manifestRequiresPython
         });
       }
     } else {
@@ -2008,7 +1702,8 @@ function computeRequiresPython(manifest, workspaceManifest, configs) {
           constraints.push({
             request: [request],
             source: workspaceManifest.path,
-            prettySource: `"requires-python" key in ${workspaceManifest.path}`
+            prettySource: `"requires-python" key in ${workspaceManifest.path}`,
+            specifier: workspaceRequiresPython
           });
         }
       }
@@ -2034,9 +1729,9 @@ function findWorkspaceManifestFor(manifest, manifestStack) {
       if (!Array.isArray(exclude)) {
         exclude = [];
       }
-      const entrypointRelPath = import_node_path6.default.relative(
-        import_node_path6.default.dirname(parentManifest.path),
-        import_node_path6.default.dirname(manifest.path)
+      const entrypointRelPath = import_node_path5.default.relative(
+        import_node_path5.default.dirname(parentManifest.path),
+        import_node_path5.default.dirname(manifest.path)
       );
       if (members.length > 0 && members.some(
         (pat) => (0, import_minimatch.match)([entrypointRelPath], pat).length > 0
@@ -2071,7 +1766,7 @@ async function loadPythonManifest(root, prefix) {
           "requirements-frozen.txt",
           "requirements.txt",
           "requirements.in",
-          import_node_path6.default.join("requirements", "prod.txt")
+          import_node_path5.default.join("requirements", "prod.txt")
         ]) {
           const requirementsTxtManifest = await maybeLoadRequirementsTxt(
             root,
@@ -2090,14 +1785,14 @@ async function loadPythonManifest(root, prefix) {
   return manifest;
 }
 async function maybeLoadLockFile(root, subdir) {
-  const uvLockRelPath = import_node_path6.default.join(subdir, "uv.lock");
-  const uvLockPath = import_node_path6.default.join(root, uvLockRelPath);
+  const uvLockRelPath = import_node_path5.default.join(subdir, "uv.lock");
+  const uvLockPath = import_node_path5.default.join(root, uvLockRelPath);
   const uvLockContent = await readFileTextIfExists(uvLockPath);
   if (uvLockContent != null) {
     return { path: uvLockRelPath, kind: "uv.lock" /* UvLock */ };
   }
-  const pylockRelPath = import_node_path6.default.join(subdir, "pylock.toml");
-  const pylockPath = import_node_path6.default.join(root, pylockRelPath);
+  const pylockRelPath = import_node_path5.default.join(subdir, "pylock.toml");
+  const pylockPath = import_node_path5.default.join(root, pylockRelPath);
   const pylockContent = await readFileTextIfExists(pylockPath);
   if (pylockContent != null) {
     return { path: pylockRelPath, kind: "pylock.toml" /* PylockToml */ };
@@ -2105,8 +1800,8 @@ async function maybeLoadLockFile(root, subdir) {
   return void 0;
 }
 async function maybeLoadPyProjectToml(root, subdir) {
-  const pyprojectTomlRelPath = import_node_path6.default.join(subdir, "pyproject.toml");
-  const pyprojectTomlPath = import_node_path6.default.join(root, pyprojectTomlRelPath);
+  const pyprojectTomlRelPath = import_node_path5.default.join(subdir, "pyproject.toml");
+  const pyprojectTomlPath = import_node_path5.default.join(root, pyprojectTomlRelPath);
   let pyproject;
   try {
     pyproject = await readConfigIfExists(
@@ -2127,8 +1822,8 @@ async function maybeLoadPyProjectToml(root, subdir) {
   if (pyproject == null) {
     return null;
   }
-  const uvTomlRelPath = import_node_path6.default.join(subdir, "uv.toml");
-  const uvTomlPath = import_node_path6.default.join(root, uvTomlRelPath);
+  const uvTomlRelPath = import_node_path5.default.join(subdir, "uv.toml");
+  const uvTomlPath = import_node_path5.default.join(root, uvTomlRelPath);
   let uvToml;
   try {
     uvToml = await readConfigIfExists(uvTomlPath, UvConfigSchema);
@@ -2158,8 +1853,8 @@ async function maybeLoadPyProjectToml(root, subdir) {
   };
 }
 async function maybeLoadPipfile(root, subdir) {
-  const pipfileRelPath = import_node_path6.default.join(subdir, "Pipfile");
-  const pipfilePath = import_node_path6.default.join(root, pipfileRelPath);
+  const pipfileRelPath = import_node_path5.default.join(subdir, "Pipfile");
+  const pipfilePath = import_node_path5.default.join(root, pipfileRelPath);
   let pipfile;
   try {
     pipfile = await readConfigIfExists(pipfilePath, PipfileLikeSchema, ".toml");
@@ -2188,8 +1883,8 @@ async function maybeLoadPipfile(root, subdir) {
   };
 }
 async function maybeLoadPipfileLock(root, subdir) {
-  const pipfileLockRelPath = import_node_path6.default.join(subdir, "Pipfile.lock");
-  const pipfileLockPath = import_node_path6.default.join(root, pipfileLockRelPath);
+  const pipfileLockRelPath = import_node_path5.default.join(subdir, "Pipfile.lock");
+  const pipfileLockPath = import_node_path5.default.join(root, pipfileLockRelPath);
   let pipfileLock;
   try {
     pipfileLock = await readConfigIfExists(
@@ -2222,14 +1917,20 @@ async function maybeLoadPipfileLock(root, subdir) {
   };
 }
 async function maybeLoadRequirementsTxt(root, subdir, fileName) {
-  const requirementsTxtRelPath = import_node_path6.default.join(subdir, fileName);
-  const requirementsTxtPath = import_node_path6.default.join(root, requirementsTxtRelPath);
+  const requirementsTxtRelPath = import_node_path5.default.join(subdir, fileName);
+  const requirementsTxtPath = import_node_path5.default.join(root, requirementsTxtRelPath);
   const requirementsContent = await readFileTextIfExists(requirementsTxtPath);
   if (requirementsContent == null) {
     return null;
   }
   try {
-    const pyproject = convertRequirementsToPyprojectToml(requirementsContent);
+    const pyproject = await convertRequirementsToPyprojectToml(
+      requirementsContent,
+      {
+        workingDir: import_node_path5.default.join(root, subdir),
+        packageRoot: root
+      }
+    );
     return {
       path: requirementsTxtRelPath,
       data: pyproject,
@@ -2263,8 +1964,8 @@ async function loadPythonConfigs(root, prefix) {
   return configs;
 }
 async function maybeLoadPythonRequest(root, subdir) {
-  const dotPythonVersionRelPath = import_node_path6.default.join(subdir, ".python-version");
-  const dotPythonVersionPath = import_node_path6.default.join(
+  const dotPythonVersionRelPath = import_node_path5.default.join(subdir, ".python-version");
+  const dotPythonVersionPath = import_node_path5.default.join(
     root,
     dotPythonVersionRelPath
   );
@@ -2283,7 +1984,8 @@ async function maybeLoadPythonRequest(root, subdir) {
   return {
     kind: ".python-version" /* PythonVersion */,
     path: dotPythonVersionRelPath,
-    data: pyreq
+    data: pyreq,
+    specifier: data.trim()
   };
 }
 
@@ -2327,7 +2029,9 @@ function parseUvLock(content, path4) {
   const packages = (parsed.package ?? []).filter((pkg) => pkg.name && pkg.version).map((pkg) => ({
     name: pkg.name,
     version: pkg.version,
-    source: pkg.source
+    source: pkg.source,
+    wheels: (pkg.wheels ?? []).map((w) => ({ url: w.url })),
+    ...pkg.dependencies ? { dependencies: pkg.dependencies } : {}
   }));
   return { version: parsed.version, packages };
 }
@@ -2383,6 +2087,20 @@ function classifyPackages(options) {
   return { privatePackages, publicPackages, packageVersions };
 }
 
+// src/manifest/wheel-compat.ts
+async function isWheelCompatible(wheelFilename, pythonMajor, pythonMinor, osName, archName, osMajor, osMinor) {
+  const mod = await importWasmModule();
+  return mod.isWheelCompatible(
+    wheelFilename,
+    pythonMajor,
+    pythonMinor,
+    osName,
+    archName,
+    osMajor,
+    osMinor
+  );
+}
+
 // src/manifest/python-selector.ts
 function selectPython(constraints, available) {
   const warnings = [];
@@ -2696,7 +2414,9 @@ var HashDigestSchema = hashDigestSchema;
   extendDistRecord,
   getStringConstant,
   isPrivatePackageSource,
+  isWheelCompatible,
   normalizePackageName,
+  parsePep508,
   parseUvLock,
   scanDistributions,
   selectPython,