From b62d97fc3a89947137685152dca7fd2e00d3da5f Mon Sep 17 00:00:00 2001
From: konstin <konstin@mailbox.org>
Date: Wed, 6 Dec 2023 11:30:43 +0100
Subject: [PATCH] Editables in pip-sync

---
 .gitignore                                    |  15 ++-
 Cargo.lock                                    |   5 +
 crates/distribution-types/src/direct_url.rs   |   6 +-
 crates/install-wheel-rs/src/lib.rs            |  17 +--
 crates/install-wheel-rs/src/wheel.rs          |   6 +-
 crates/puffin-cli/Cargo.toml                  |   3 +
 crates/puffin-cli/src/commands/pip_compile.rs |  87 +++++++++++++--
 crates/puffin-cli/src/commands/pip_sync.rs    |  83 ++++++++++++--
 .../puffin-cli/src/commands/pip_uninstall.rs  |   2 +
 crates/puffin-cli/src/requirements.rs         |  19 +++-
 crates/puffin-cli/tests/pip_compile.rs        |  51 +++++++++
 crates/puffin-cli/tests/pip_sync.rs           |  85 +++++++++++++++
 crates/puffin-client/src/lib.rs               |   4 +-
 crates/puffin-client/src/registry_client.rs   |  74 ++++++-------
 crates/puffin-client/src/remote_metadata.rs   |   2 +-
 crates/puffin-dev/src/resolve_cli.rs          |   7 +-
 crates/puffin-dispatch/src/lib.rs             |  12 ++-
 crates/puffin-installer/Cargo.toml            |   1 +
 crates/puffin-installer/src/plan.rs           |  33 ++++--
 crates/puffin-installer/src/site_packages.rs  |  18 +++-
 crates/puffin-resolver/Cargo.toml             |   3 +-
 crates/puffin-resolver/src/manifest.rs        |  16 +++
 crates/puffin-resolver/src/resolution.rs      |  43 +++++---
 crates/puffin-resolver/src/resolver.rs        |  30 +++++-
 crates/puffin-resolver/tests/resolver.rs      | 101 +++++-------------
 crates/pypi-types/src/direct_url.rs           |   7 +-
 crates/requirements-txt/src/lib.rs            |  45 +++++++-
 .../maturin_editable/pyproject.toml           |   2 +-
 .../python/maturin_editable/__init__.py       |   6 +-
 .../poetry_editable/pyproject.toml            |   1 +
 scripts/editable-installs/requirements.in     |   3 +
 scripts/editable-installs/requirements.txt    |  14 +++
 32 files changed, 602 insertions(+), 199 deletions(-)
 create mode 100644 scripts/editable-installs/requirements.in
 create mode 100644 scripts/editable-installs/requirements.txt

diff --git a/.gitignore b/.gitignore
index da5e94a6c32..79d27d5bf09 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,3 @@
-.venv
-
 # Generated by Cargo
 # will have compiled files and executables
 debug/
@@ -14,5 +12,16 @@ target/
 # Use e.g. `--cache-dir cache-docker` to keep a cache across container invocations
 cache-*
 
-# python tmp files
+# Python tmp files
 __pycache__
+
+# Maturin builds, and other native editable builds
+*.so
+*.pyd
+*.dll
+
+# Profiling
+flamegraph.svg
+perf.data
+perf.data.old
+profile.json
diff --git a/Cargo.lock b/Cargo.lock
index 8f922b04a91..d58c1e0349a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2301,11 +2301,13 @@ dependencies = [
  "chrono",
  "clap",
  "colored",
+ "distribution-filename",
  "distribution-types",
  "fs-err",
  "futures",
  "gourgeist",
  "indicatif",
+ "indoc",
  "insta",
  "insta-cmd",
  "install-wheel-rs",
@@ -2318,6 +2320,7 @@ dependencies = [
  "platform-tags",
  "predicates",
  "pubgrub",
+ "puffin-build",
  "puffin-cache",
  "puffin-client",
  "puffin-dispatch",
@@ -2532,6 +2535,7 @@ dependencies = [
  "puffin-traits",
  "pypi-types",
  "rayon",
+ "requirements-txt",
  "rustc-hash",
  "tempfile",
  "thiserror",
@@ -2614,6 +2618,7 @@ dependencies = [
  "puffin-normalize",
  "puffin-traits",
  "pypi-types",
+ "requirements-txt",
  "reqwest",
  "rustc-hash",
  "serde_json",
diff --git a/crates/distribution-types/src/direct_url.rs b/crates/distribution-types/src/direct_url.rs
index a25a6160c69..75e29c31f99 100644
--- a/crates/distribution-types/src/direct_url.rs
+++ b/crates/distribution-types/src/direct_url.rs
@@ -130,7 +130,7 @@ impl TryFrom<&LocalFileUrl> for pypi_types::DirectUrl {
 
     fn try_from(value: &LocalFileUrl) -> Result<Self, Self::Error> {
         Ok(pypi_types::DirectUrl::LocalDirectory {
-            url: value.url.to_string(),
+            url: value.url.clone(),
             dir_info: pypi_types::DirInfo { editable: None },
         })
     }
@@ -141,7 +141,7 @@ impl TryFrom<&DirectArchiveUrl> for pypi_types::DirectUrl {
 
     fn try_from(value: &DirectArchiveUrl) -> Result<Self, Self::Error> {
         Ok(pypi_types::DirectUrl::ArchiveUrl {
-            url: value.url.to_string(),
+            url: value.url.clone(),
             archive_info: pypi_types::ArchiveInfo {
                 hash: None,
                 hashes: None,
@@ -156,7 +156,7 @@ impl TryFrom<&DirectGitUrl> for pypi_types::DirectUrl {
 
     fn try_from(value: &DirectGitUrl) -> Result<Self, Self::Error> {
         Ok(pypi_types::DirectUrl::VcsUrl {
-            url: value.url.repository().to_string(),
+            url: value.url.repository().clone(),
             vcs_info: pypi_types::VcsInfo {
                 vcs: pypi_types::VcsKind::Git,
                 commit_id: value.url.precise().as_ref().map(ToString::to_string),
diff --git a/crates/install-wheel-rs/src/lib.rs b/crates/install-wheel-rs/src/lib.rs
index 181fac067a6..8961eaaec1e 100644
--- a/crates/install-wheel-rs/src/lib.rs
+++ b/crates/install-wheel-rs/src/lib.rs
@@ -92,6 +92,8 @@ pub enum Error {
 /// the metadata name and the dist info name are lowercase, while the wheel name is uppercase.
 /// Either way, we just search the wheel for the name.
 ///
+/// Returns the dist info dir prefix with the `.dist-info` extension.
+///
 /// Reference implementation: <https://github.com/pypa/packaging/blob/2f83540272e79e3fe1f5d42abae8df0c14ddf4c2/src/packaging/utils.py#L146-L172>
 pub fn find_dist_info<'a, T: Copy>(
     filename: &WheelFilename,
@@ -106,13 +108,13 @@ pub fn find_dist_info<'a, T: Copy>(
                 && Version::from_str(version).ok()? == filename.version
                 && file == "METADATA"
             {
-                Some((payload, dist_info_dir))
+                Some((payload, dir_stem))
             } else {
                 None
             }
         })
         .collect();
-    let (payload, dist_info_dir) = match metadatas[..] {
+    let (payload, dist_info_prefix) = match metadatas[..] {
         [] => {
             return Err(Error::MissingDistInfo);
         }
@@ -127,7 +129,7 @@ pub fn find_dist_info<'a, T: Copy>(
             ));
         }
     };
-    Ok((payload, dist_info_dir))
+    Ok((payload, dist_info_prefix))
 }
 
 /// Given an archive, read the `dist-info` metadata into a buffer.
@@ -135,10 +137,11 @@ pub fn read_dist_info(
     filename: &WheelFilename,
     archive: &mut ZipArchive<impl Read + Seek + Sized>,
 ) -> Result<Vec<u8>, Error> {
-    let dist_info_dir = find_dist_info(filename, archive.file_names().map(|name| (name, name)))?.1;
+    let dist_info_prefix =
+        find_dist_info(filename, archive.file_names().map(|name| (name, name)))?.1;
 
     let mut file = archive
-        .by_name(&format!("{dist_info_dir}/METADATA"))
+        .by_name(&format!("{dist_info_prefix}.dist-info/METADATA"))
         .map_err(|err| Error::Zip(filename.to_string(), err))?;
 
     #[allow(clippy::cast_possible_truncation)]
@@ -170,8 +173,8 @@ mod test {
             "Mastodon.py-1.5.1.dist-info/RECORD",
         ];
         let filename = WheelFilename::from_str("Mastodon.py-1.5.1-py2.py3-none-any.whl").unwrap();
-        let (_, dist_info_dir) =
+        let (_, dist_info_prefix) =
             find_dist_info(&filename, files.into_iter().map(|file| (file, file))).unwrap();
-        assert_eq!(dist_info_dir, "Mastodon.py-1.5.1.dist-info");
+        assert_eq!(dist_info_prefix, "Mastodon.py-1.5.1");
     }
 }
diff --git a/crates/install-wheel-rs/src/wheel.rs b/crates/install-wheel-rs/src/wheel.rs
index b7a66448602..8d4173f842f 100644
--- a/crates/install-wheel-rs/src/wheel.rs
+++ b/crates/install-wheel-rs/src/wheel.rs
@@ -82,10 +82,10 @@ pub(crate) fn read_scripts_from_section(
 /// Extras are supposed to be ignored, which happens if you pass None for extras
 fn parse_scripts<R: Read + Seek>(
     archive: &mut ZipArchive<R>,
-    dist_info_prefix: &str,
+    dist_info_dir: &str,
     extras: Option<&[String]>,
 ) -> Result<(Vec<Script>, Vec<Script>), Error> {
-    let entry_points_path = format!("{dist_info_prefix}.dist-info/entry_points.txt");
+    let entry_points_path = format!("{dist_info_dir}/entry_points.txt");
     let entry_points_mapping = match archive.by_name(&entry_points_path) {
         Ok(mut file) => {
             let mut ini_text = String::new();
@@ -1043,7 +1043,7 @@ fn dist_info_metadata(
     archive: &mut ZipArchive<impl Read + Seek + Sized>,
 ) -> Result<Vec<u8>, Error> {
     let mut content = Vec::new();
-    let dist_info_file = format!("{dist_info_prefix}.dist-info/DIST-INFO");
+    let dist_info_file = format!("{dist_info_prefix}.dist-info/METADATA");
     archive
         .by_name(&dist_info_file)
         .map_err(|err| Error::Zip(dist_info_file.clone(), err))?
diff --git a/crates/puffin-cli/Cargo.toml b/crates/puffin-cli/Cargo.toml
index 50f79268891..170f5b69bdf 100644
--- a/crates/puffin-cli/Cargo.toml
+++ b/crates/puffin-cli/Cargo.toml
@@ -27,6 +27,8 @@ puffin-cache = { path = "../puffin-cache", features = ["clap"] }
 puffin-client = { path = "../puffin-client" }
 puffin-dispatch = { path = "../puffin-dispatch" }
 distribution-types = { path = "../distribution-types" }
+distribution-filename = { path = "../distribution-filename" }
+puffin-build = { path = "../puffin-build" }
 puffin-distribution = { path = "../puffin-distribution" }
 puffin-installer = { path = "../puffin-installer" }
 puffin-interpreter = { path = "../puffin-interpreter" }
@@ -71,6 +73,7 @@ tikv-jemallocator = "0.5.0"
 [dev-dependencies]
 assert_cmd = { version = "2.0.12" }
 assert_fs = { version = "1.0.13" }
+indoc = { version = "2.0.4" }
 insta-cmd = { version = "0.4.0" }
 insta = { version = "1.34.0", features = ["filters"] }
 predicates = { version = "3.0.4" }
diff --git a/crates/puffin-cli/src/commands/pip_compile.rs b/crates/puffin-cli/src/commands/pip_compile.rs
index 8d0aab845ae..ca703424eab 100644
--- a/crates/puffin-cli/src/commands/pip_compile.rs
+++ b/crates/puffin-cli/src/commands/pip_compile.rs
@@ -1,25 +1,29 @@
 use std::borrow::Cow;
+use std::env;
 use std::fmt::Write;
 use std::io::stdout;
 use std::path::Path;
 use std::str::FromStr;
-use std::{env, fs};
 
 use anstream::AutoStream;
-use anyhow::{anyhow, Result};
+use anyhow::{anyhow, Context, Result};
 use chrono::{DateTime, Utc};
 use colored::Colorize;
 use itertools::Itertools;
+use tempfile::tempdir_in;
 use tracing::debug;
 
-use pep508_rs::Requirement;
+use distribution_filename::WheelFilename;
+use distribution_types::{PathSourceDist, SourceDist};
+use pep508_rs::{Requirement, VersionOrUrl};
 use platform_host::Platform;
 use platform_tags::Tags;
+use puffin_build::{BuildKind, SourceBuild, SourceBuildContext};
 use puffin_cache::Cache;
-use puffin_client::RegistryClientBuilder;
+use puffin_client::{read_metadata_async, RegistryClientBuilder};
 use puffin_dispatch::BuildDispatch;
 use puffin_interpreter::Virtualenv;
-use puffin_normalize::ExtraName;
+use puffin_normalize::{ExtraName, PackageName};
 use puffin_resolver::{Manifest, PreReleaseMode, ResolutionMode, ResolutionOptions, Resolver};
 use pypi_types::IndexUrls;
 
@@ -74,8 +78,9 @@ pub(crate) async fn pip_compile(
     // Read all requirements from the provided sources.
     let RequirementsSpecification {
         project,
-        requirements,
+        mut requirements,
         constraints,
+        editables,
         extras: used_extras,
     } = RequirementsSpecification::try_from_sources(requirements, constraints, &extras)?;
 
@@ -108,7 +113,6 @@ pub(crate) async fn pip_compile(
         .unwrap_or_default();
 
     // Create a manifest of the requirements.
-    let manifest = Manifest::new(requirements, constraints, preferences, project);
     let options = ResolutionOptions::new(resolution_mode, prerelease_mode, exclude_newer);
 
     // Detect the current Python interpreter.
@@ -142,12 +146,75 @@ pub(crate) async fn pip_compile(
         client.clone(),
         cache.clone(),
         interpreter,
-        fs::canonicalize(venv.python_executable())?,
+        fs_err::canonicalize(venv.python_executable())?,
         no_build,
         index_urls,
     )
     .with_options(options);
 
+    // Build the editables and add their requirements
+    let mut editable_deps = Vec::new();
+    if !editables.is_empty() {
+        let reporter = ResolverReporter::from(printer);
+        for editable in editables {
+            debug!("Building (editable) {editable}");
+            let package_name = PackageName::new(format!(
+                "editable-at-{}",
+                editable
+                    .unwrap_path()
+                    .file_name()
+                    .unwrap()
+                    .to_str()
+                    .unwrap()
+            ))
+            .unwrap();
+            let source_dist = SourceDist::Path(PathSourceDist {
+                name: package_name,
+                url: editable.url(),
+                path: editable.unwrap_path().to_path_buf(),
+            });
+            let idx = puffin_resolver::ResolverReporter::on_build_start(&reporter, &source_dist);
+            let editable_wheel_dir = tempdir_in(venv.root())?;
+            let builder = SourceBuild::setup(
+                editable.unwrap_path(),
+                None,
+                venv.interpreter(),
+                &build_dispatch,
+                SourceBuildContext::default(),
+                &editable.to_string(),
+                BuildKind::Editable,
+            )
+            .await
+            .context(format!("Failed to build editable {editable}"))?;
+            let wheel_name = builder.build(editable_wheel_dir.path()).await?;
+            let filename = WheelFilename::from_str(&wheel_name)
+                .context(format!("Invalid wheel filename for editable {editable}"))?;
+            let reader = fs_err::tokio::File::open(editable_wheel_dir.path().join(wheel_name))
+                .await
+                .context(format!("No wheel built for editable {editable}"))?;
+            let metadata = read_metadata_async(&filename, editable.to_string(), reader)
+                .await
+                .context(format!("Invalid wheel for editable {editable}"))?;
+
+            requirements.push(Requirement {
+                name: filename.name.clone(),
+                extras: None,
+                version_or_url: Some(VersionOrUrl::Url(editable.url().clone())),
+                marker: None,
+            });
+            editable_deps.push((editable.clone(), filename, metadata));
+            puffin_resolver::ResolverReporter::on_build_complete(&reporter, &source_dist, idx);
+        }
+    }
+
+    let manifest = Manifest::new(
+        requirements,
+        constraints,
+        preferences,
+        project,
+        editable_deps,
+    );
+
     // Resolve the dependencies.
     let resolver = Resolver::new(manifest, options, &markers, &tags, &client, &build_dispatch)
         .with_reporter(ResolverReporter::from(printer));
@@ -177,7 +244,9 @@ pub(crate) async fn pip_compile(
     )?;
 
     let mut writer: Box<dyn std::io::Write> = if let Some(output_file) = output_file {
-        Box::new(AutoStream::auto(fs::File::create(output_file)?))
+        Box::new(AutoStream::<std::fs::File>::auto(
+            fs_err::File::create(output_file)?.into(),
+        ))
     } else {
         Box::new(AutoStream::auto(stdout()))
     };
diff --git a/crates/puffin-cli/src/commands/pip_sync.rs b/crates/puffin-cli/src/commands/pip_sync.rs
index b73d1667a44..8a82c2cdf2f 100644
--- a/crates/puffin-cli/src/commands/pip_sync.rs
+++ b/crates/puffin-cli/src/commands/pip_sync.rs
@@ -1,23 +1,29 @@
 use std::fmt::Write;
+use std::str::FromStr;
 
-use anyhow::{Context, Result};
+use anyhow::{format_err, Context, Result};
 use colored::Colorize;
+use distribution_filename::WheelFilename;
 use fs_err as fs;
 use itertools::Itertools;
+use tempfile::tempdir_in;
 use tracing::debug;
+use url::Url;
 
 use distribution_types::{AnyDist, Metadata};
 use install_wheel_rs::linker::LinkMode;
 use pep508_rs::Requirement;
 use platform_host::Platform;
 use platform_tags::Tags;
+use puffin_build::{BuildKind, SourceBuild, SourceBuildContext};
 use puffin_cache::Cache;
 use puffin_client::RegistryClientBuilder;
 use puffin_dispatch::BuildDispatch;
 use puffin_installer::{Downloader, InstallPlan, Reinstall};
 use puffin_interpreter::Virtualenv;
 use puffin_traits::OnceMap;
-use pypi_types::{IndexUrls, Yanked};
+use pypi_types::{DirInfo, IndexUrls, Yanked};
+use requirements_txt::EditableRequirement;
 
 use crate::commands::reporters::{DownloadReporter, FinderReporter, InstallReporter};
 use crate::commands::{elapsed, ExitStatus};
@@ -39,10 +45,11 @@ pub(crate) async fn pip_sync(
         project: _,
         requirements,
         constraints: _,
+        editables,
         extras: _,
     } = RequirementsSpecification::try_from_sources(sources, &[], &ExtrasSpecification::None)?;
 
-    if requirements.is_empty() {
+    if requirements.is_empty() && editables.is_empty() {
         writeln!(printer, "No requirements found")?;
         return Ok(ExitStatus::Success);
     }
@@ -50,6 +57,7 @@ pub(crate) async fn pip_sync(
     sync_requirements(
         &requirements,
         reinstall,
+        &editables,
         link_mode,
         index_urls,
         no_build,
@@ -60,9 +68,11 @@ pub(crate) async fn pip_sync(
 }
 
 /// Install a set of locked requirements into the current Python environment.
+#[allow(clippy::too_many_arguments)]
 pub(crate) async fn sync_requirements(
     requirements: &[Requirement],
     reinstall: &Reinstall,
+    editables: &[EditableRequirement],
     link_mode: LinkMode,
     index_urls: IndexUrls,
     no_build: bool,
@@ -80,28 +90,28 @@ pub(crate) async fn sync_requirements(
     );
 
     // Determine the current environment markers.
-    let markers = venv.interpreter().markers();
     let tags = Tags::from_interpreter(venv.interpreter())?;
 
     // Partition into those that should be linked from the cache (`local`), those that need to be
     // downloaded (`remote`), and those that should be removed (`extraneous`).
     let InstallPlan {
         local,
+        editables,
         remote,
         extraneous,
     } = InstallPlan::from_requirements(
         requirements,
         reinstall,
+        editables,
         &index_urls,
         cache,
         &venv,
-        markers,
         &tags,
     )
     .context("Failed to determine installation plan")?;
 
     // Nothing to do.
-    if remote.is_empty() && local.is_empty() && extraneous.is_empty() {
+    if remote.is_empty() && local.is_empty() && extraneous.is_empty() && editables.is_empty() {
         let s = if requirements.len() == 1 { "" } else { "s" };
         writeln!(
             printer,
@@ -175,7 +185,9 @@ pub(crate) async fn sync_requirements(
     }
 
     // Download, build, and unzip any missing distributions.
-    let wheels = if remote.is_empty() {
+    let editable_wheel_dir = tempdir_in(venv.root())?;
+    let mut built_editables = Vec::new();
+    let wheels = if remote.is_empty() && editables.is_empty() {
         vec![]
     } else {
         let start = std::time::Instant::now();
@@ -189,6 +201,22 @@ pub(crate) async fn sync_requirements(
             index_urls.clone(),
         );
 
+        for editable in editables {
+            debug!("Building (editable) {editable}");
+            let builder = SourceBuild::setup(
+                editable.unwrap_path(),
+                None,
+                venv.interpreter(),
+                &build_dispatch,
+                SourceBuildContext::default(),
+                &editable.to_string(),
+                BuildKind::Editable,
+            )
+            .await?;
+            let wheel_name = builder.build(editable_wheel_dir.path()).await?;
+            built_editables.push((editable, wheel_name));
+        }
+
         let downloader = Downloader::new(cache, &tags, &client, &build_dispatch)
             .with_reporter(DownloadReporter::from(printer).with_length(remote.len() as u64));
 
@@ -243,20 +271,55 @@ pub(crate) async fn sync_requirements(
 
     // Install the resolved distributions.
     let wheels = wheels.into_iter().chain(local).collect::<Vec<_>>();
-    if !wheels.is_empty() {
+    if !wheels.is_empty() || !built_editables.is_empty() {
         let start = std::time::Instant::now();
         puffin_installer::Installer::new(&venv)
             .with_link_mode(link_mode)
             .with_reporter(InstallReporter::from(printer).with_length(wheels.len() as u64))
             .install(&wheels)?;
 
-        let s = if wheels.len() == 1 { "" } else { "s" };
+        let location = install_wheel_rs::InstallLocation::new(
+            venv.root().to_path_buf(),
+            venv.interpreter().simple_version(),
+        )
+        .acquire_lock()?;
+
+        for (editable_requirement, editable_name) in &built_editables {
+            let mut reader = fs::File::open(editable_wheel_dir.path().join(&editable_name))
+                .context("Failed to open built distribution for TODO(konstin)")?;
+            let direct_url = pypi_types::DirectUrl::LocalDirectory {
+                url: Url::from_directory_path(fs::canonicalize(
+                    editable_requirement.unwrap_path(),
+                )?)
+                .map_err(|()| format_err!("Failed to convert path to url"))?,
+                dir_info: DirInfo {
+                    editable: Some(true),
+                },
+            };
+            install_wheel_rs::install_wheel(
+                &location,
+                &mut reader,
+                &WheelFilename::from_str(&editable_name)?,
+                Some(&direct_url),
+                false,
+                false,
+                &[],
+                &venv.python_executable(),
+            )
+            .context("Failed to install TODO(konstin)")?;
+        }
+
+        let s = if wheels.len() + built_editables.len() == 1 {
+            ""
+        } else {
+            "s"
+        };
         writeln!(
             printer,
             "{}",
             format!(
                 "Installed {} in {}",
-                format!("{} package{}", wheels.len(), s).bold(),
+                format!("{} package{}", wheels.len() + built_editables.len(), s).bold(),
                 elapsed(start.elapsed())
             )
             .dimmed()
diff --git a/crates/puffin-cli/src/commands/pip_uninstall.rs b/crates/puffin-cli/src/commands/pip_uninstall.rs
index 22bb8a8e3e2..42109796f37 100644
--- a/crates/puffin-cli/src/commands/pip_uninstall.rs
+++ b/crates/puffin-cli/src/commands/pip_uninstall.rs
@@ -26,6 +26,8 @@ pub(crate) async fn pip_uninstall(
         project: _,
         requirements,
         constraints: _,
+        // TODO(konstin): Uninstall editables too
+        editables: _,
         extras: _,
     } = RequirementsSpecification::try_from_sources(sources, &[], &ExtrasSpecification::None)?;
 
diff --git a/crates/puffin-cli/src/requirements.rs b/crates/puffin-cli/src/requirements.rs
index cddbe19c365..79b30bf8857 100644
--- a/crates/puffin-cli/src/requirements.rs
+++ b/crates/puffin-cli/src/requirements.rs
@@ -9,7 +9,7 @@ use fs_err as fs;
 
 use pep508_rs::Requirement;
 use puffin_normalize::{ExtraName, PackageName};
-use requirements_txt::RequirementsTxt;
+use requirements_txt::{EditableRequirement, RequirementsTxt};
 
 #[derive(Debug)]
 pub(crate) enum RequirementsSource {
@@ -64,6 +64,8 @@ pub(crate) struct RequirementsSpecification {
     pub(crate) requirements: Vec<Requirement>,
     /// The constraints for the project.
     pub(crate) constraints: Vec<Requirement>,
+    /// Package to install as editable installs
+    pub(crate) editables: Vec<EditableRequirement>,
     /// The extras used to collect requirements.
     pub(crate) extras: HashSet<ExtraName>,
 }
@@ -82,19 +84,24 @@ impl RequirementsSpecification {
                     project: None,
                     requirements: vec![requirement],
                     constraints: vec![],
+                    editables: vec![],
                     extras: HashSet::new(),
                 }
             }
             RequirementsSource::RequirementsTxt(path) => {
-                let requirements_txt = RequirementsTxt::parse(path, std::env::current_dir()?)?;
+                let RequirementsTxt {
+                    requirements,
+                    constraints,
+                    editable: editables,
+                } = RequirementsTxt::parse(path, std::env::current_dir()?)?;
                 Self {
                     project: None,
-                    requirements: requirements_txt
-                        .requirements
+                    requirements: requirements
                         .into_iter()
                         .map(|entry| entry.requirement)
                         .collect(),
-                    constraints: requirements_txt.constraints.into_iter().collect(),
+                    constraints,
+                    editables,
                     extras: HashSet::new(),
                 }
             }
@@ -131,6 +138,7 @@ impl RequirementsSpecification {
                     project: project_name,
                     requirements,
                     constraints: vec![],
+                    editables: vec![],
                     extras: used_extras,
                 }
             }
@@ -153,6 +161,7 @@ impl RequirementsSpecification {
             spec.requirements.extend(source.requirements);
             spec.constraints.extend(source.constraints);
             spec.extras.extend(source.extras);
+            spec.editables.extend(source.editables);
 
             // Use the first project name discovered
             if spec.project.is_none() {
diff --git a/crates/puffin-cli/tests/pip_compile.rs b/crates/puffin-cli/tests/pip_compile.rs
index 9d36dd4dd6b..4b23f3e2f55 100644
--- a/crates/puffin-cli/tests/pip_compile.rs
+++ b/crates/puffin-cli/tests/pip_compile.rs
@@ -6,6 +6,7 @@ use anyhow::Result;
 use assert_cmd::prelude::*;
 use assert_fs::prelude::*;
 use assert_fs::TempDir;
+use indoc::indoc;
 use insta_cmd::_macro_support::insta;
 use insta_cmd::{assert_cmd_snapshot, get_cargo_bin};
 
@@ -1606,3 +1607,53 @@ fn compile_yanked_version_indirect() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn compile_editable() -> Result<()> {
+    let temp_dir = TempDir::new()?;
+    let cache_dir = TempDir::new()?;
+    let venv = create_venv_py312(&temp_dir, &cache_dir);
+
+    let requirements_in = temp_dir.child("requirements.in");
+    requirements_in.write_str(indoc! {r"
+        -e ../../scripts/editable-installs/poetry_editable
+        -e ../../scripts/editable-installs/maturin_editable
+        boltons # normal depedency for comparison
+        "
+    })?;
+
+    let filter_path = requirements_in.display().to_string();
+    let filters = INSTA_FILTERS
+        .iter()
+        .chain(&[(filter_path.as_str(), "requirements.in")])
+        .copied()
+        .collect::<Vec<_>>();
+    insta::with_settings!({
+        filters => filters
+    }, {
+        assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+            .arg("pip-compile")
+            .arg(requirements_in.path())
+            .arg("--cache-dir")
+            .arg(cache_dir.path())
+            .arg("--exclude-newer")
+            .arg(EXCLUDE_NEWER)
+            .env("VIRTUAL_ENV", venv.as_os_str()), @r###"
+        success: true
+        exit_code: 0
+        ----- stdout -----
+        # This file was autogenerated by Puffin v0.0.1 via the following command:
+        #    puffin pip-compile requirements.in --cache-dir [CACHE_DIR]
+        boltons==23.1.1
+        -e /home/konsti/projects/puffin/crates/puffin-cli/../../scripts/editable-installs/maturin_editable
+        numpy==1.26.2
+            # via poetry-editable
+        -e /home/konsti/projects/puffin/crates/puffin-cli/../../scripts/editable-installs/poetry_editable
+
+        ----- stderr -----
+        Resolved 4 packages in [TIME]
+        "###);
+    });
+
+    Ok(())
+}
diff --git a/crates/puffin-cli/tests/pip_sync.rs b/crates/puffin-cli/tests/pip_sync.rs
index 4fa26341d50..c45e69ebdc4 100644
--- a/crates/puffin-cli/tests/pip_sync.rs
+++ b/crates/puffin-cli/tests/pip_sync.rs
@@ -6,6 +6,8 @@ use std::process::Command;
 use anyhow::{Context, Result};
 use assert_cmd::prelude::*;
 use assert_fs::prelude::*;
+use assert_fs::TempDir;
+use indoc::indoc;
 use insta_cmd::_macro_support::insta;
 use insta_cmd::{assert_cmd_snapshot, get_cargo_bin};
 
@@ -15,6 +17,8 @@ mod common;
 
 fn check_command(venv: &Path, command: &str, temp_dir: &Path) {
     Command::new(venv.join("bin").join("python"))
+        // https://github.com/python/cpython/issues/75953
+        .arg("-B")
         .arg("-c")
         .arg(command)
         .current_dir(temp_dir)
@@ -1829,3 +1833,84 @@ fn reinstall_package() -> Result<()> {
 
     Ok(())
 }
+
+#[test]
+fn install_editable() -> Result<()> {
+    let temp_dir = TempDir::new()?;
+    let cache_dir = TempDir::new()?;
+    let venv = create_venv_py312(&temp_dir, &cache_dir);
+
+    let requirements_txt = temp_dir.child("requirements.txt");
+    requirements_txt.write_str(indoc! {r"
+        boltons==23.1.1
+        -e ../../scripts/editable-installs/maturin_editable
+        numpy==1.26.2
+            # via poetry-editable
+        -e ../../scripts/editable-installs/poetry_editable
+        "
+    })?;
+
+    let filter_path = requirements_txt.display().to_string();
+    let filters = INSTA_FILTERS
+        .iter()
+        .chain(&[(filter_path.as_str(), "requirements.in")])
+        .copied()
+        .collect::<Vec<_>>();
+    insta::with_settings!({
+        filters => filters
+    }, {
+        assert_cmd_snapshot!(Command::new(get_cargo_bin(BIN_NAME))
+            .arg("pip-sync")
+            .arg(requirements_txt.path())
+            .arg("--cache-dir")
+            .arg(cache_dir.path())
+            .env("VIRTUAL_ENV", venv.as_os_str())
+            .env("CARGO_TARGET_DIR", "../../../target/target_install_editable"), @r###"
+        success: true
+        exit_code: 0
+        ----- stdout -----
+
+        ----- stderr -----
+        Resolved 2 packages in [TIME]
+        Downloaded 2 packages in [TIME]
+        Installed 2 packages in [TIME]
+         + boltons==23.1.1
+         + numpy==1.26.2
+        "###);
+    });
+
+    // Make sure we have the right base case
+    let python_source_file =
+        "../../scripts/editable-installs/maturin_editable/python/maturin_editable/__init__.py";
+    let python_version_1 = indoc! {r"
+        from .maturin_editable import *
+        version = 1
+   "};
+    fs_err::write(python_source_file, python_version_1)?;
+
+    let command = indoc! {r#"
+        from maturin_editable import sum_as_string, version
+                
+        assert version == 1, version
+        assert sum_as_string(1, 2) == "3", sum_as_string(1, 2)
+   "#};
+    check_command(&venv, command, &temp_dir);
+
+    // Edit the sources
+    let python_version_2 = indoc! {r"
+        from .maturin_editable import *
+        version = 2
+   "};
+    fs_err::write(python_source_file, python_version_2)?;
+
+    let command = indoc! {r#"
+        from maturin_editable import sum_as_string, version
+        from pathlib import Path
+        
+        assert version == 2, version
+        assert sum_as_string(1, 2) == "3", sum_as_string(1, 2)
+   "#};
+    check_command(&venv, command, &temp_dir);
+
+    Ok(())
+}
diff --git a/crates/puffin-client/src/lib.rs b/crates/puffin-client/src/lib.rs
index 27d5e05bfaf..c002a2401da 100644
--- a/crates/puffin-client/src/lib.rs
+++ b/crates/puffin-client/src/lib.rs
@@ -1,6 +1,8 @@
 pub use cached_client::{CachedClient, CachedClientError, DataWithCachePolicy};
 pub use error::Error;
-pub use registry_client::{RegistryClient, RegistryClientBuilder, SimpleMetadata};
+pub use registry_client::{
+    read_metadata_async, RegistryClient, RegistryClientBuilder, SimpleMetadata,
+};
 
 mod cached_client;
 mod error;
diff --git a/crates/puffin-client/src/registry_client.rs b/crates/puffin-client/src/registry_client.rs
index 348df405773..0e7b2a8537b 100644
--- a/crates/puffin-client/src/registry_client.rs
+++ b/crates/puffin-client/src/registry_client.rs
@@ -208,8 +208,7 @@ impl RegistryClient {
             }
             BuiltDist::Path(wheel) => {
                 let reader = fs_err::tokio::File::open(&wheel.path).await?;
-                Self::metadata_from_async_read(&wheel.filename, built_dist.to_string(), reader)
-                    .await?
+                read_metadata_async(&wheel.filename, built_dist.to_string(), reader).await?
             }
         };
 
@@ -329,41 +328,7 @@ impl RegistryClient {
             .map_err(Error::CacheWrite)?;
         let reader = writer.into_inner();
 
-        Self::metadata_from_async_read(filename, url.to_string(), reader).await
-    }
-
-    async fn metadata_from_async_read(
-        filename: &WheelFilename,
-        debug_source: String,
-        reader: impl tokio::io::AsyncRead + tokio::io::AsyncSeek + Unpin,
-    ) -> Result<Metadata21, Error> {
-        let mut zip_reader = ZipFileReader::with_tokio(reader)
-            .await
-            .map_err(|err| Error::Zip(filename.clone(), err))?;
-
-        let (metadata_idx, _dist_info_dir) = find_dist_info(
-            filename,
-            zip_reader
-                .file()
-                .entries()
-                .iter()
-                .enumerate()
-                .filter_map(|(idx, e)| Some((idx, e.entry().filename().as_str().ok()?))),
-        )?;
-
-        // Read the contents of the METADATA file
-        let mut contents = Vec::new();
-        zip_reader
-            .reader_with_entry(metadata_idx)
-            .await
-            .map_err(|err| Error::Zip(filename.clone(), err))?
-            .read_to_end_checked(&mut contents)
-            .await
-            .map_err(|err| Error::Zip(filename.clone(), err))?;
-
-        let metadata = Metadata21::parse(&contents)
-            .map_err(|err| Error::MetadataParseError(filename.clone(), debug_source, err))?;
-        Ok(metadata)
+        read_metadata_async(filename, url.to_string(), reader).await
     }
 
     /// Stream a file from an external URL.
@@ -389,6 +354,41 @@ impl RegistryClient {
     }
 }
 
+/// It doesn't really fit into `puffin_client`, but it avoids cyclical crate dependencies.
+pub async fn read_metadata_async(
+    filename: &WheelFilename,
+    debug_source: String,
+    reader: impl tokio::io::AsyncRead + tokio::io::AsyncSeek + Unpin,
+) -> Result<Metadata21, Error> {
+    let mut zip_reader = ZipFileReader::with_tokio(reader)
+        .await
+        .map_err(|err| Error::Zip(filename.clone(), err))?;
+
+    let (metadata_idx, _dist_info_prefix) = find_dist_info(
+        filename,
+        zip_reader
+            .file()
+            .entries()
+            .iter()
+            .enumerate()
+            .filter_map(|(idx, e)| Some((idx, e.entry().filename().as_str().ok()?))),
+    )?;
+
+    // Read the contents of the METADATA file
+    let mut contents = Vec::new();
+    zip_reader
+        .reader_with_entry(metadata_idx)
+        .await
+        .map_err(|err| Error::Zip(filename.clone(), err))?
+        .read_to_end_checked(&mut contents)
+        .await
+        .map_err(|err| Error::Zip(filename.clone(), err))?;
+
+    let metadata = Metadata21::parse(&contents)
+        .map_err(|err| Error::MetadataParseError(filename.clone(), debug_source, err))?;
+    Ok(metadata)
+}
+
 #[derive(Default, Debug, Serialize, Deserialize)]
 pub struct VersionFiles {
     pub wheels: Vec<(WheelFilename, File)>,
diff --git a/crates/puffin-client/src/remote_metadata.rs b/crates/puffin-client/src/remote_metadata.rs
index b21be34114d..82fcc4217ea 100644
--- a/crates/puffin-client/src/remote_metadata.rs
+++ b/crates/puffin-client/src/remote_metadata.rs
@@ -65,7 +65,7 @@ pub(crate) async fn wheel_metadata_from_remote_zip(
         .await
         .map_err(|err| Error::Zip(filename.clone(), err))?;
 
-    let ((metadata_idx, metadata_entry), _path) = find_dist_info(
+    let ((metadata_idx, metadata_entry), _dist_info_prefix) = find_dist_info(
         filename,
         reader
             .file()
diff --git a/crates/puffin-dev/src/resolve_cli.rs b/crates/puffin-dev/src/resolve_cli.rs
index 20462c6dc91..7ee64dc2093 100644
--- a/crates/puffin-dev/src/resolve_cli.rs
+++ b/crates/puffin-dev/src/resolve_cli.rs
@@ -60,12 +60,7 @@ pub(crate) async fn resolve_cli(args: ResolveCliArgs) -> Result<()> {
     // Copied from `BuildDispatch`
     let tags = Tags::from_interpreter(venv.interpreter())?;
     let resolver = Resolver::new(
-        Manifest::new(
-            args.requirements.clone(),
-            Vec::default(),
-            Vec::default(),
-            None,
-        ),
+        Manifest::from_requirements(args.requirements.clone()),
         ResolutionOptions::default(),
         venv.interpreter().markers(),
         &tags,
diff --git a/crates/puffin-dispatch/src/lib.rs b/crates/puffin-dispatch/src/lib.rs
index 7cb3d49317f..937bdbfaa23 100644
--- a/crates/puffin-dispatch/src/lib.rs
+++ b/crates/puffin-dispatch/src/lib.rs
@@ -90,7 +90,13 @@ impl BuildContext for BuildDispatch {
         Box::pin(async {
             let tags = Tags::from_interpreter(&self.interpreter)?;
             let resolver = Resolver::new(
-                Manifest::new(requirements.to_vec(), Vec::default(), Vec::default(), None),
+                Manifest::new(
+                    requirements.to_vec(),
+                    Vec::default(),
+                    Vec::default(),
+                    None,
+                    Vec::default(),
+                ),
                 self.options,
                 self.interpreter.markers(),
                 &tags,
@@ -126,20 +132,20 @@ impl BuildContext for BuildDispatch {
                 venv.root().display(),
             );
 
-            let markers = self.interpreter.markers();
             let tags = Tags::from_interpreter(&self.interpreter)?;
 
             let InstallPlan {
                 local,
                 remote,
                 extraneous,
+                editables: _,
             } = InstallPlan::from_requirements(
                 requirements,
                 &Reinstall::None,
+                &[],
                 &self.index_urls,
                 self.cache(),
                 venv,
-                markers,
                 &tags,
             )?;
 
diff --git a/crates/puffin-installer/Cargo.toml b/crates/puffin-installer/Cargo.toml
index 9cba1136ff3..0f00a971165 100644
--- a/crates/puffin-installer/Cargo.toml
+++ b/crates/puffin-installer/Cargo.toml
@@ -28,6 +28,7 @@ puffin-interpreter = { path = "../puffin-interpreter" }
 puffin-normalize = { path = "../puffin-normalize" }
 puffin-traits = { path = "../puffin-traits" }
 pypi-types = { path = "../pypi-types" }
+requirements-txt = { path = "../requirements-txt" }
 
 anyhow = { workspace = true }
 fs-err = { workspace = true }
diff --git a/crates/puffin-installer/src/plan.rs b/crates/puffin-installer/src/plan.rs
index 8494b9f804f..391348a1804 100644
--- a/crates/puffin-installer/src/plan.rs
+++ b/crates/puffin-installer/src/plan.rs
@@ -5,16 +5,16 @@ use rustc_hash::FxHashMap;
 use tracing::debug;
 
 use distribution_types::direct_url::{git_reference, DirectUrl};
-use distribution_types::{
-    BuiltDist, CachedDirectUrlDist, CachedDist, Dist, InstalledDist, Metadata, SourceDist,
-};
-use pep508_rs::{MarkerEnvironment, Requirement, VersionOrUrl};
+use distribution_types::{BuiltDist, Dist, SourceDist};
+use distribution_types::{CachedDirectUrlDist, CachedDist, InstalledDist, Metadata};
+use pep508_rs::{Requirement, VersionOrUrl};
 use platform_tags::Tags;
 use puffin_cache::{Cache, CacheBucket, WheelCache};
 use puffin_distribution::{BuiltWheelIndex, RegistryWheelIndex};
 use puffin_interpreter::Virtualenv;
 use puffin_normalize::PackageName;
 use pypi_types::IndexUrls;
+use requirements_txt::EditableRequirement;
 
 use crate::SitePackages;
 
@@ -31,6 +31,12 @@ pub struct InstallPlan {
     /// The distributions that are already installed in the current environment, and are
     /// _not_ necessary to satisfy the requirements.
     pub extraneous: Vec<InstalledDist>,
+
+    /// Editable installs that are missing in the current environment.
+    ///
+    /// Since editable installs happen from a path through a non-cacheable wheel, we don't have to
+    /// divide those into cached and non-cached.
+    pub editables: Vec<EditableRequirement>,
 }
 
 impl InstallPlan {
@@ -39,10 +45,10 @@ impl InstallPlan {
     pub fn from_requirements(
         requirements: &[Requirement],
         reinstall: &Reinstall,
+        editable_requirements: &[EditableRequirement],
         index_urls: &IndexUrls,
         cache: &Cache,
         venv: &Virtualenv,
-        env: &MarkerEnvironment,
         tags: &Tags,
     ) -> Result<Self> {
         // Index all the already-installed packages in site-packages.
@@ -55,12 +61,26 @@ impl InstallPlan {
         let mut local = vec![];
         let mut remote = vec![];
         let mut extraneous = vec![];
+        let mut editables = vec![];
         let mut seen =
             FxHashMap::with_capacity_and_hasher(requirements.len(), BuildHasherDefault::default());
 
+        for editable in editable_requirements {
+            let editable_dist = site_packages
+                .editables()
+                .find(|(_dist, url, _dir_info)| *url == &editable.url())
+                .map(|(dist, _url, _dir_info)| dist.clone());
+            if let Some(dist) = editable_dist {
+                debug!("Treating editable requirement as immutable: {editable}");
+                site_packages.remove(dist.name());
+            } else {
+                editables.push(editable.clone());
+            }
+        }
+
         for requirement in requirements {
             // Filter out incompatible requirements.
-            if !requirement.evaluate_markers(env, &[]) {
+            if !requirement.evaluate_markers(venv.interpreter().markers(), &[]) {
                 continue;
             }
 
@@ -268,6 +288,7 @@ impl InstallPlan {
             local,
             remote,
             extraneous,
+            editables,
         })
     }
 }
diff --git a/crates/puffin-installer/src/site_packages.rs b/crates/puffin-installer/src/site_packages.rs
index 346b2ef40ae..8be991b67b7 100644
--- a/crates/puffin-installer/src/site_packages.rs
+++ b/crates/puffin-installer/src/site_packages.rs
@@ -2,10 +2,12 @@ use std::collections::BTreeMap;
 
 use anyhow::{Context, Result};
 use fs_err as fs;
+use url::Url;
 
-use distribution_types::{InstalledDist, Metadata};
+use distribution_types::{InstalledDirectUrlDist, InstalledDist, Metadata};
 use puffin_interpreter::Virtualenv;
 use puffin_normalize::PackageName;
+use pypi_types::{DirInfo, DirectUrl};
 
 #[derive(Debug, Default)]
 pub struct SitePackages(BTreeMap<PackageName, InstalledDist>);
@@ -36,6 +38,20 @@ impl SitePackages {
         self.0.values()
     }
 
+    /// Returns an iterator over the installed editables.
+    pub fn editables(&self) -> impl Iterator<Item = (&InstalledDist, &Url, &DirInfo)> {
+        self.distributions().filter_map(|dist| {
+            // Editable installs are recorded through this type only
+            match dist {
+                InstalledDist::Url(InstalledDirectUrlDist {
+                    url: DirectUrl::LocalDirectory { url, dir_info },
+                    ..
+                }) if dir_info.editable == Some(true) => Some((dist, url, dir_info)),
+                _ => None,
+            }
+        })
+    }
+
     /// Returns the version of the given package, if it is installed.
     pub fn get(&self, name: &PackageName) -> Option<&InstalledDist> {
         self.0.get(name)
diff --git a/crates/puffin-resolver/Cargo.toml b/crates/puffin-resolver/Cargo.toml
index 17f2a36dbee..9d6f791fbfe 100644
--- a/crates/puffin-resolver/Cargo.toml
+++ b/crates/puffin-resolver/Cargo.toml
@@ -14,6 +14,7 @@ workspace = true
 
 [dependencies]
 distribution-filename = { path = "../distribution-filename", features = ["serde"] }
+distribution-types = { path = "../distribution-types" }
 install-wheel-rs = { path = "../install-wheel-rs" }
 pep440_rs = { path = "../pep440-rs" }
 pep508_rs = { path = "../pep508-rs" }
@@ -21,7 +22,6 @@ platform-host = { path = "../platform-host" }
 platform-tags = { path = "../platform-tags" }
 puffin-cache = { path = "../puffin-cache" }
 puffin-client = { path = "../puffin-client" }
-distribution-types = { path = "../distribution-types" }
 puffin-distribution = { path = "../puffin-distribution" }
 puffin-git = { path = "../puffin-git" }
 puffin-interpreter = { path = "../puffin-interpreter" }
@@ -29,6 +29,7 @@ puffin-macros = { path = "../puffin-macros" }
 puffin-normalize = { path = "../puffin-normalize" }
 puffin-traits = { path = "../puffin-traits" }
 pypi-types = { path = "../pypi-types" }
+requirements-txt = { path = "../requirements-txt" }
 
 anyhow = { workspace = true }
 bitflags = { workspace = true }
diff --git a/crates/puffin-resolver/src/manifest.rs b/crates/puffin-resolver/src/manifest.rs
index 6767d08cd9d..c97ebd8f857 100644
--- a/crates/puffin-resolver/src/manifest.rs
+++ b/crates/puffin-resolver/src/manifest.rs
@@ -1,5 +1,8 @@
+use distribution_filename::WheelFilename;
 use pep508_rs::Requirement;
 use puffin_normalize::PackageName;
+use pypi_types::Metadata21;
+use requirements_txt::EditableRequirement;
 
 /// A manifest of requirements, constraints, and preferences.
 #[derive(Debug)]
@@ -8,6 +11,7 @@ pub struct Manifest {
     pub(crate) constraints: Vec<Requirement>,
     pub(crate) preferences: Vec<Requirement>,
     pub(crate) project: Option<PackageName>,
+    pub(crate) editables: Vec<(EditableRequirement, WheelFilename, Metadata21)>,
 }
 
 impl Manifest {
@@ -16,12 +20,24 @@ impl Manifest {
         constraints: Vec<Requirement>,
         preferences: Vec<Requirement>,
         project: Option<PackageName>,
+        editables: Vec<(EditableRequirement, WheelFilename, Metadata21)>,
     ) -> Self {
         Self {
             requirements,
             constraints,
             preferences,
             project,
+            editables,
+        }
+    }
+
+    pub fn from_requirements(requirements: Vec<Requirement>) -> Self {
+        Self {
+            requirements,
+            constraints: Vec::default(),
+            preferences: Vec::default(),
+            project: None,
+            editables: Vec::default(),
         }
     }
 }
diff --git a/crates/puffin-resolver/src/resolution.rs b/crates/puffin-resolver/src/resolution.rs
index f562245ccf0..dc3fed4f272 100644
--- a/crates/puffin-resolver/src/resolution.rs
+++ b/crates/puffin-resolver/src/resolution.rs
@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 use std::hash::BuildHasherDefault;
 
 use anyhow::Result;
@@ -7,15 +8,17 @@ use petgraph::Direction;
 use pubgrub::range::Range;
 use pubgrub::solver::{Kind, State};
 use pubgrub::type_aliases::SelectedDependencies;
-use rustc_hash::FxHashMap;
 use url::Url;
 
+use distribution_filename::WheelFilename;
 use distribution_types::{BuiltDist, Dist, Metadata, SourceDist};
 use pep440_rs::{Version, VersionSpecifier, VersionSpecifiers};
 use pep508_rs::{Requirement, VersionOrUrl};
 use puffin_normalize::PackageName;
 use puffin_traits::OnceMap;
-use pypi_types::{File, IndexUrl};
+use pypi_types::{File, IndexUrl, Metadata21};
+use requirements_txt::EditableRequirement;
+use rustc_hash::FxHashMap;
 
 use crate::pubgrub::{PubGrubPackage, PubGrubPriority, PubGrubVersion};
 use crate::ResolveError;
@@ -54,7 +57,10 @@ impl Resolution {
 /// A complete resolution graph in which every node represents a pinned package and every edge
 /// represents a dependency between two pinned packages.
 #[derive(Debug)]
-pub struct Graph(pub petgraph::graph::Graph<Dist, Range<PubGrubVersion>, petgraph::Directed>);
+pub struct Graph {
+    pub graph: petgraph::graph::Graph<Dist, Range<PubGrubVersion>, petgraph::Directed>,
+    editables: HashMap<String, (EditableRequirement, WheelFilename, Metadata21)>,
+}
 
 impl Graph {
     /// Create a new graph from the resolved `PubGrub` state.
@@ -63,6 +69,7 @@ impl Graph {
         pins: &FxHashMap<PackageName, FxHashMap<Version, (IndexUrl, File)>>,
         redirects: &OnceMap<Url, Url>,
         state: &State<PubGrubPackage, Range<PubGrubVersion>, PubGrubPriority>,
+        editables: HashMap<String, (EditableRequirement, WheelFilename, Metadata21)>,
     ) -> Result<Self, ResolveError> {
         // TODO(charlie): petgraph is a really heavy and unnecessary dependency here. We should
         // write our own graph, given that our requirements are so simple.
@@ -126,30 +133,30 @@ impl Graph {
             }
         }
 
-        Ok(Self(graph))
+        Ok(Self { graph, editables })
     }
 
     /// Return the number of packages in the graph.
     pub fn len(&self) -> usize {
-        self.0.node_count()
+        self.graph.node_count()
     }
 
     /// Return `true` if there are no packages in the graph.
     pub fn is_empty(&self) -> bool {
-        self.0.node_count() == 0
+        self.graph.node_count() == 0
     }
 
     pub fn requirements(&self) -> Vec<Requirement> {
         // Collect and sort all packages.
         let mut nodes = self
-            .0
+            .graph
             .node_indices()
-            .map(|node| (node, &self.0[node]))
+            .map(|node| (node, &self.graph[node]))
             .collect::<Vec<_>>();
         nodes.sort_unstable_by_key(|(_, package)| package.name());
-        self.0
+        self.graph
             .node_indices()
-            .map(|node| match &self.0[node] {
+            .map(|node| match &self.graph[node] {
                 Dist::Built(BuiltDist::Registry(wheel)) => Requirement {
                     name: wheel.name.clone(),
                     extras: None,
@@ -204,7 +211,7 @@ impl Graph {
     pub fn petgraph(
         &self,
     ) -> &petgraph::graph::Graph<Dist, Range<PubGrubVersion>, petgraph::Directed> {
-        &self.0
+        &self.graph
     }
 }
 
@@ -213,20 +220,24 @@ impl std::fmt::Display for Graph {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         // Collect and sort all packages.
         let mut nodes = self
-            .0
+            .graph
             .node_indices()
-            .map(|node| (node, &self.0[node]))
+            .map(|node| (node, &self.graph[node]))
             .collect::<Vec<_>>();
         nodes.sort_unstable_by_key(|(_, package)| package.name());
 
         // Print out the dependency graph.
         for (index, package) in nodes {
-            writeln!(f, "{package}")?;
+            if let Some((editable_requirement, _, _)) = self.editables.get(&package.to_string()) {
+                writeln!(f, "-e {editable_requirement}")?;
+            } else {
+                writeln!(f, "{package}")?;
+            }
 
             let mut edges = self
-                .0
+                .graph
                 .edges_directed(index, Direction::Incoming)
-                .map(|edge| &self.0[edge.source()])
+                .map(|edge| &self.graph[edge.source()])
                 .collect::<Vec<_>>();
             edges.sort_unstable_by_key(|package| package.name());
 
diff --git a/crates/puffin-resolver/src/resolver.rs b/crates/puffin-resolver/src/resolver.rs
index 82ac8c03fbe..20bfbcc179a 100644
--- a/crates/puffin-resolver/src/resolver.rs
+++ b/crates/puffin-resolver/src/resolver.rs
@@ -1,5 +1,6 @@
 //! Given a set of requirements, find a set of compatible packages.
 
+use std::collections::HashMap;
 use std::future::Future;
 use std::pin::Pin;
 use std::sync::Arc;
@@ -8,8 +9,6 @@ use anyhow::Result;
 use chrono::{DateTime, Utc};
 use futures::channel::mpsc::UnboundedReceiver;
 use futures::{pin_mut, FutureExt, StreamExt, TryFutureExt};
-use rustc_hash::{FxHashMap, FxHashSet};
-
 use pubgrub::error::PubGrubError;
 use pubgrub::range::Range;
 use pubgrub::solver::{Incompatibility, State};
@@ -28,6 +27,8 @@ use puffin_distribution::{DistributionDatabase, DistributionDatabaseError};
 use puffin_normalize::{ExtraName, PackageName};
 use puffin_traits::{BuildContext, OnceMap};
 use pypi_types::{File, IndexUrl, Metadata21};
+use requirements_txt::EditableRequirement;
+use rustc_hash::{FxHashMap, FxHashSet};
 
 use crate::candidate_selector::CandidateSelector;
 use crate::error::ResolveError;
@@ -156,6 +157,7 @@ pub struct Resolver<'a, Provider: ResolverProvider> {
     markers: &'a MarkerEnvironment,
     selector: CandidateSelector,
     index: Arc<Index>,
+    editables: HashMap<String, (EditableRequirement, WheelFilename, Metadata21)>,
     reporter: Option<Arc<dyn Reporter>>,
     provider: Provider,
 }
@@ -195,9 +197,20 @@ impl<'a, Provider: ResolverProvider> Resolver<'a, Provider> {
         markers: &'a MarkerEnvironment,
         provider: Provider,
     ) -> Self {
+        let selector = CandidateSelector::for_resolution(&manifest, options);
+
+        let index = Index::default();
+        let mut editables = HashMap::new();
+        for (editable_requirement, filename, metadata) in manifest.editables {
+            let dist = Dist::from_url(filename.name.clone(), editable_requirement.url())
+                .expect("This is a valid distribution");
+            index.distributions.done(dist.to_string(), metadata.clone());
+            editables.insert(dist.to_string(), (editable_requirement, filename, metadata));
+        }
+
         Self {
-            index: Arc::new(Index::default()),
-            selector: CandidateSelector::for_resolution(&manifest, options),
+            index: Arc::new(index),
+            selector,
             allowed_urls: manifest
                 .requirements
                 .iter()
@@ -214,6 +227,7 @@ impl<'a, Provider: ResolverProvider> Resolver<'a, Provider> {
             requirements: manifest.requirements,
             constraints: manifest.constraints,
             markers,
+            editables,
             reporter: None,
             provider,
         }
@@ -296,7 +310,13 @@ impl<'a, Provider: ResolverProvider> Resolver<'a, Provider> {
                     })
             else {
                 let selection = state.partial_solution.extract_solution();
-                return Graph::from_state(&selection, &pins, &self.index.redirects, &state);
+                return Graph::from_state(
+                    &selection,
+                    &pins,
+                    &self.index.redirects,
+                    &state,
+                    self.editables.clone(),
+                );
             };
             next = highest_priority_pkg;
 
diff --git a/crates/puffin-resolver/tests/resolver.rs b/crates/puffin-resolver/tests/resolver.rs
index fbe51520f59..488631762e7 100644
--- a/crates/puffin-resolver/tests/resolver.rs
+++ b/crates/puffin-resolver/tests/resolver.rs
@@ -99,12 +99,8 @@ async fn resolve(
 async fn black() -> Result<()> {
     colored::control::set_override(false);
 
-    let manifest = Manifest::new(
-        vec![Requirement::from_str("black<=23.9.1").unwrap()],
-        vec![],
-        vec![],
-        None,
-    );
+    let manifest =
+        Manifest::from_requirements(vec![Requirement::from_str("black<=23.9.1").unwrap()]);
     let options = ResolutionOptions::new(
         ResolutionMode::default(),
         PreReleaseMode::default(),
@@ -122,12 +118,10 @@ async fn black() -> Result<()> {
 async fn black_colorama() -> Result<()> {
     colored::control::set_override(false);
 
-    let manifest = Manifest::new(
-        vec![Requirement::from_str("black[colorama]<=23.9.1").unwrap()],
-        vec![],
-        vec![],
-        None,
-    );
+    let manifest =
+        Manifest::from_requirements(vec![
+            Requirement::from_str("black[colorama]<=23.9.1").unwrap()
+        ]);
     let options = ResolutionOptions::new(
         ResolutionMode::default(),
         PreReleaseMode::default(),
@@ -145,12 +139,8 @@ async fn black_colorama() -> Result<()> {
 async fn black_python_310() -> Result<()> {
     colored::control::set_override(false);
 
-    let manifest = Manifest::new(
-        vec![Requirement::from_str("black<=23.9.1").unwrap()],
-        vec![],
-        vec![],
-        None,
-    );
+    let manifest =
+        Manifest::from_requirements(vec![Requirement::from_str("black<=23.9.1").unwrap()]);
     let options = ResolutionOptions::new(
         ResolutionMode::default(),
         PreReleaseMode::default(),
@@ -175,6 +165,7 @@ async fn black_mypy_extensions() -> Result<()> {
         vec![Requirement::from_str("mypy-extensions<0.4.4").unwrap()],
         vec![],
         None,
+        vec![],
     );
     let options = ResolutionOptions::new(
         ResolutionMode::default(),
@@ -200,6 +191,7 @@ async fn black_mypy_extensions_extra() -> Result<()> {
         vec![Requirement::from_str("mypy-extensions[extra]<0.4.4").unwrap()],
         vec![],
         None,
+        vec![],
     );
     let options = ResolutionOptions::new(
         ResolutionMode::default(),
@@ -225,6 +217,7 @@ async fn black_flake8() -> Result<()> {
         vec![Requirement::from_str("flake8<1").unwrap()],
         vec![],
         None,
+        vec![],
     );
     let options = ResolutionOptions::new(
         ResolutionMode::default(),
@@ -243,12 +236,7 @@ async fn black_flake8() -> Result<()> {
 async fn black_lowest() -> Result<()> {
     colored::control::set_override(false);
 
-    let manifest = Manifest::new(
-        vec![Requirement::from_str("black>21").unwrap()],
-        vec![],
-        vec![],
-        None,
-    );
+    let manifest = Manifest::from_requirements(vec![Requirement::from_str("black>21").unwrap()]);
     let options = ResolutionOptions::new(
         ResolutionMode::Lowest,
         PreReleaseMode::default(),
@@ -266,12 +254,7 @@ async fn black_lowest() -> Result<()> {
 async fn black_lowest_direct() -> Result<()> {
     colored::control::set_override(false);
 
-    let manifest = Manifest::new(
-        vec![Requirement::from_str("black>21").unwrap()],
-        vec![],
-        vec![],
-        None,
-    );
+    let manifest = Manifest::from_requirements(vec![Requirement::from_str("black>21").unwrap()]);
     let options = ResolutionOptions::new(
         ResolutionMode::LowestDirect,
         PreReleaseMode::default(),
@@ -294,6 +277,7 @@ async fn black_respect_preference() -> Result<()> {
         vec![],
         vec![Requirement::from_str("black==23.9.0").unwrap()],
         None,
+        vec![],
     );
     let options = ResolutionOptions::new(
         ResolutionMode::default(),
@@ -317,6 +301,7 @@ async fn black_ignore_preference() -> Result<()> {
         vec![],
         vec![Requirement::from_str("black==23.9.2").unwrap()],
         None,
+        vec![],
     );
     let options = ResolutionOptions::new(
         ResolutionMode::default(),
@@ -335,12 +320,7 @@ async fn black_ignore_preference() -> Result<()> {
 async fn black_disallow_prerelease() -> Result<()> {
     colored::control::set_override(false);
 
-    let manifest = Manifest::new(
-        vec![Requirement::from_str("black<=20.0").unwrap()],
-        vec![],
-        vec![],
-        None,
-    );
+    let manifest = Manifest::from_requirements(vec![Requirement::from_str("black<=20.0").unwrap()]);
     let options = ResolutionOptions::new(
         ResolutionMode::default(),
         PreReleaseMode::Disallow,
@@ -360,12 +340,7 @@ async fn black_disallow_prerelease() -> Result<()> {
 async fn black_allow_prerelease_if_necessary() -> Result<()> {
     colored::control::set_override(false);
 
-    let manifest = Manifest::new(
-        vec![Requirement::from_str("black<=20.0").unwrap()],
-        vec![],
-        vec![],
-        None,
-    );
+    let manifest = Manifest::from_requirements(vec![Requirement::from_str("black<=20.0").unwrap()]);
     let options = ResolutionOptions::new(
         ResolutionMode::default(),
         PreReleaseMode::IfNecessary,
@@ -385,12 +360,8 @@ async fn black_allow_prerelease_if_necessary() -> Result<()> {
 async fn pylint_disallow_prerelease() -> Result<()> {
     colored::control::set_override(false);
 
-    let manifest = Manifest::new(
-        vec![Requirement::from_str("pylint==2.3.0").unwrap()],
-        vec![],
-        vec![],
-        None,
-    );
+    let manifest =
+        Manifest::from_requirements(vec![Requirement::from_str("pylint==2.3.0").unwrap()]);
     let options = ResolutionOptions::new(
         ResolutionMode::default(),
         PreReleaseMode::Disallow,
@@ -408,12 +379,8 @@ async fn pylint_disallow_prerelease() -> Result<()> {
 async fn pylint_allow_prerelease() -> Result<()> {
     colored::control::set_override(false);
 
-    let manifest = Manifest::new(
-        vec![Requirement::from_str("pylint==2.3.0").unwrap()],
-        vec![],
-        vec![],
-        None,
-    );
+    let manifest =
+        Manifest::from_requirements(vec![Requirement::from_str("pylint==2.3.0").unwrap()]);
     let options = ResolutionOptions::new(
         ResolutionMode::default(),
         PreReleaseMode::Allow,
@@ -431,15 +398,10 @@ async fn pylint_allow_prerelease() -> Result<()> {
 async fn pylint_allow_explicit_prerelease_without_marker() -> Result<()> {
     colored::control::set_override(false);
 
-    let manifest = Manifest::new(
-        vec![
-            Requirement::from_str("pylint==2.3.0").unwrap(),
-            Requirement::from_str("isort>=5.0.0").unwrap(),
-        ],
-        vec![],
-        vec![],
-        None,
-    );
+    let manifest = Manifest::from_requirements(vec![
+        Requirement::from_str("pylint==2.3.0").unwrap(),
+        Requirement::from_str("isort>=5.0.0").unwrap(),
+    ]);
     let options = ResolutionOptions::new(
         ResolutionMode::default(),
         PreReleaseMode::Explicit,
@@ -457,15 +419,10 @@ async fn pylint_allow_explicit_prerelease_without_marker() -> Result<()> {
 async fn pylint_allow_explicit_prerelease_with_marker() -> Result<()> {
     colored::control::set_override(false);
 
-    let manifest = Manifest::new(
-        vec![
-            Requirement::from_str("pylint==2.3.0").unwrap(),
-            Requirement::from_str("isort>=5.0.0b").unwrap(),
-        ],
-        vec![],
-        vec![],
-        None,
-    );
+    let manifest = Manifest::from_requirements(vec![
+        Requirement::from_str("pylint==2.3.0").unwrap(),
+        Requirement::from_str("isort>=5.0.0b").unwrap(),
+    ]);
     let options = ResolutionOptions::new(
         ResolutionMode::default(),
         PreReleaseMode::Explicit,
diff --git a/crates/pypi-types/src/direct_url.rs b/crates/pypi-types/src/direct_url.rs
index 3a33269f28f..a1881d0fcfe 100644
--- a/crates/pypi-types/src/direct_url.rs
+++ b/crates/pypi-types/src/direct_url.rs
@@ -2,6 +2,7 @@ use std::collections::HashMap;
 use std::path::PathBuf;
 
 use serde::{Deserialize, Serialize};
+use url::Url;
 
 /// Metadata for a distribution that was installed via a direct URL.
 ///
@@ -13,13 +14,13 @@ pub enum DirectUrl {
     /// ```json
     /// {"url": "file:///home/user/project", "dir_info": {}}
     /// ```
-    LocalDirectory { url: String, dir_info: DirInfo },
+    LocalDirectory { url: Url, dir_info: DirInfo },
     /// The direct URL is a path to an archive. For example:
     /// ```json
     /// {"archive_info": {"hash": "sha256=75909db2664838d015e3d9139004ee16711748a52c8f336b52882266540215d8", "hashes": {"sha256": "75909db2664838d015e3d9139004ee16711748a52c8f336b52882266540215d8"}}, "url": "https://files.pythonhosted.org/packages/b8/8b/31273bf66016be6ad22bb7345c37ff350276cfd46e389a0c2ac5da9d9073/wheel-0.41.2-py3-none-any.whl"}
     /// ```
     ArchiveUrl {
-        url: String,
+        url: Url,
         archive_info: ArchiveInfo,
         #[serde(skip_serializing_if = "Option::is_none")]
         subdirectory: Option<PathBuf>,
@@ -29,7 +30,7 @@ pub enum DirectUrl {
     /// {"url": "https://github.com/pallets/flask.git", "vcs_info": {"commit_id": "8d9519df093864ff90ca446d4af2dc8facd3c542", "vcs": "git"}}
     /// ```
     VcsUrl {
-        url: String,
+        url: Url,
         vcs_info: VcsInfo,
         #[serde(skip_serializing_if = "Option::is_none")]
         subdirectory: Option<PathBuf>,
diff --git a/crates/requirements-txt/src/lib.rs b/crates/requirements-txt/src/lib.rs
index 797a0c1d03c..1448a3e3abc 100644
--- a/crates/requirements-txt/src/lib.rs
+++ b/crates/requirements-txt/src/lib.rs
@@ -73,6 +73,49 @@ pub enum EditableRequirement {
     Url(Url),
 }
 
+impl EditableRequirement {
+    pub fn unwrap_path(&self) -> &Path {
+        match self {
+            EditableRequirement::Path(path) => path,
+            EditableRequirement::Url(_) => {
+                todo!("url editables")
+            }
+        }
+    }
+
+    #[must_use]
+    pub fn with_working_dir(self, working_dir: impl AsRef<Path>) -> Self {
+        match self {
+            EditableRequirement::Path(path) => {
+                if path.is_absolute() {
+                    EditableRequirement::Path(path)
+                } else {
+                    EditableRequirement::Path(working_dir.as_ref().join(path))
+                }
+            }
+            EditableRequirement::Url(url) => EditableRequirement::Url(url),
+        }
+    }
+
+    pub fn url(&self) -> Url {
+        match self {
+            EditableRequirement::Path(path) => {
+                Url::from_directory_path(path).expect("Path valid for url")
+            }
+            EditableRequirement::Url(url) => url.clone(),
+        }
+    }
+}
+
+impl Display for EditableRequirement {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            EditableRequirement::Path(path) => path.display().fmt(f),
+            EditableRequirement::Url(url) => url.fmt(f),
+        }
+    }
+}
+
 /// A [Requirement] with additional metadata from the requirements.txt, currently only hashes but in
 /// the future also editable an similar information
 #[derive(Debug, Deserialize, Clone, Eq, PartialEq, Serialize)]
@@ -193,7 +236,7 @@ impl RequirementsTxt {
                     data.requirements.push(requirement_entry);
                 }
                 RequirementsTxtStatement::EditableRequirement(editable) => {
-                    data.editable.push(editable);
+                    data.editable.push(editable.with_working_dir(&working_dir));
                 }
             }
         }
diff --git a/scripts/editable-installs/maturin_editable/pyproject.toml b/scripts/editable-installs/maturin_editable/pyproject.toml
index 9b0d2b8e7c5..0c251ddb9ed 100644
--- a/scripts/editable-installs/maturin_editable/pyproject.toml
+++ b/scripts/editable-installs/maturin_editable/pyproject.toml
@@ -8,5 +8,5 @@ python-source = "python"
 features = ["pyo3/extension-module"]
 
 [build-system]
-requires = ["maturin>=1.4,<2.0"]
+requires = ["maturin>=1,<2"]
 build-backend = "maturin"
diff --git a/scripts/editable-installs/maturin_editable/python/maturin_editable/__init__.py b/scripts/editable-installs/maturin_editable/python/maturin_editable/__init__.py
index 9ba4a68b436..2a7fb9e370d 100644
--- a/scripts/editable-installs/maturin_editable/python/maturin_editable/__init__.py
+++ b/scripts/editable-installs/maturin_editable/python/maturin_editable/__init__.py
@@ -1,6 +1,2 @@
 from .maturin_editable import *
-
-
-__doc__ = maturin_editable.__doc__
-if hasattr(maturin_editable, "__all__"):
-    __all__ = maturin_editable.__all__
+version = 2
diff --git a/scripts/editable-installs/poetry_editable/pyproject.toml b/scripts/editable-installs/poetry_editable/pyproject.toml
index 890ae09606e..de9b0b94fe5 100644
--- a/scripts/editable-installs/poetry_editable/pyproject.toml
+++ b/scripts/editable-installs/poetry_editable/pyproject.toml
@@ -6,6 +6,7 @@ authors = ["konstin <konstin@mailbox.org>"]
 
 [tool.poetry.dependencies]
 python = "^3.10"
+numpy = "^1"
 
 [build-system]
 requires = ["poetry-core"]
diff --git a/scripts/editable-installs/requirements.in b/scripts/editable-installs/requirements.in
new file mode 100644
index 00000000000..e49f5ae6b3a
--- /dev/null
+++ b/scripts/editable-installs/requirements.in
@@ -0,0 +1,3 @@
+-e scripts/editable-installs/poetry_editable
+-e scripts/editable-installs/maturin_editable
+boltons # normal depedency for comparison
diff --git a/scripts/editable-installs/requirements.txt b/scripts/editable-installs/requirements.txt
new file mode 100644
index 00000000000..9b3ea6c7115
--- /dev/null
+++ b/scripts/editable-installs/requirements.txt
@@ -0,0 +1,14 @@
+#
+# This file is autogenerated by pip-compile with Python 3.12
+# by the following command:
+#
+#    pip-compile scripts/editable-installs/requirements.in
+#
+-e scripts/editable-installs/maturin_editable
+    # via -r scripts/editable-installs/requirements.in
+-e scripts/editable-installs/poetry_editable
+    # via -r scripts/editable-installs/requirements.in
+boltons==23.1.1
+    # via -r scripts/editable-installs/requirements.in
+numpy==1.26.2
+    # via poetry-editable