@vercel/python-analysis 0.9.0 → 0.10.0

package/dist/index.js

@@ -2,6 +2,84 @@
 import { readFile } from "fs/promises";
 import { createRequire } from "module";
 import { dirname, join } from "path";
+
+// src/wasm/host-utils.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { normalize } from "path/posix";
+import { domainToUnicode as nodeDomainToUnicode } from "url";
+var readFileStorage = new 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 = nodeDomainToUnicode(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 = normalize(path4);
+  if (!workingDir) {
+    return normalized;
+  }
+  const normalizedDir = 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;
@@ -29,7 +107,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;
@@ -824,356 +905,98 @@ var PyProjectToolSectionSchema = pyProjectToolSectionSchema.passthrough();
 var PyProjectTomlSchema = pyProjectTomlSchema.passthrough();
 
 // src/manifest/requirements-txt-parser.ts
-import { normalize } from "path";
-import { parsePipRequirementsFile } from "pip-requirements-js";
+import { isAbsolute, join as join3, relative } from "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
-  };
-}
-function isGitUrl(url) {
-  return url.startsWith("git+");
+  return wasm.parseRequirementsTxt(content, workingDir ?? void 0, void 0);
 }
-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 (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 (entry.markers) {
+    req.markers = entry.markers;
   }
-  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() || "";
+    req.source = source;
   }
-  if (!filename)
-    return null;
-  let name;
-  let version;
-  const wheelParsed = parseWheelFilename(filename);
-  if (wheelParsed) {
-    name = wheelParsed.name;
-    version = wheelParsed.version;
-  }
-  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 (isAbsolute(p))
+    return p;
+  const abs = join3(workingDir, p);
+  const rel = relative(packageRoot, abs);
+  if (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];
       }
     }
   }
@@ -1223,216 +1046,38 @@ 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 = 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 = 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
-  };
-}
-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
+    pipOptions
   };
-  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
@@ -2151,7 +1796,13 @@ async function maybeLoadRequirementsTxt(root, subdir, fileName) {
     return null;
   }
   try {
-    const pyproject = convertRequirementsToPyprojectToml(requirementsContent);
+    const pyproject = await convertRequirementsToPyprojectToml(
+      requirementsContent,
+      {
+        workingDir: path3.join(root, subdir),
+        packageRoot: root
+      }
+    );
     return {
       path: requirementsTxtRelPath,
       data: pyproject,
@@ -2249,7 +1900,8 @@ 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 }))
   }));
   return { version: parsed.version, packages };
 }
@@ -2305,6 +1957,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 = [];
@@ -2617,6 +2283,7 @@ export {
   extendDistRecord,
   getStringConstant,
   isPrivatePackageSource,
+  isWheelCompatible,
   normalizePackageName2 as normalizePackageName,
   parseUvLock,
   scanDistributions,