diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8153865a..ac44cccc 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -51,6 +51,75 @@ into the new version's section — see docs/releasing.md.
 
 ### Added
 
+- **Python patches survive uv lockfiles in both hosted and vendored modes.**
+  `scan --mode hosted|vendored` now rewrites native `uv.lock` together with
+  the paired `pyproject.toml` source and metadata, PEP 723 script locks
+  (`*.py.lock` plus the script's inline metadata), PEP 751 `pylock*.toml`,
+  and uv-compiled hashed `requirements.txt`, so `uv sync --frozen|--locked`,
+  `uv run --script`, and `uv pip sync --require-hashes` install the patched
+  wheel instead of the registry artifact. Verified against real uv binaries
+  from every 0.x release family (0.0 through 0.12) — first and latest release
+  of each plus every observed behaviour boundary — see
+  `docs/testing/uv-compatibility.md`: hosted mode covers requirements from
+  uv 0.0.5 and native `uv.lock` from 0.1.45 — the first release whose
+  `uv lock` writes one — through all three `[[distribution]]` lock shapes
+  and `[[package]]`; vendored native covers every `[[package]]` release
+  (uv ≥ 0.2.35), vendored requirements cover uv ≥ 0.1.24 (hash-enforced by
+  `uv pip sync --require-hashes` from 0.1.32 and by default from 0.5.x).
+  Follow-up hardening:
+  `vendor --revert` refuses to delete a vendored Python wheel a lock still
+  references when the ledger entry has no wiring to replay (the shape
+  `repair` rebuilds), a script or PEP 751 lock supplements rather than hides
+  `poetry.lock`/`requirements.txt` pins, symlinked locks are discovered, and
+  refused before any write (never rewritten in place — uv writes through the
+  link, an atomic rename would replace it; hosted
+  `redirect_symlinked_file_unsupported`, vendored
+  `pypi_uv_symlink_unsupported` / `pypi_lock_symlink_unsupported`), CRLF
+  locks keep their line endings in both the hosted rewriter and the vendored
+  uv backend (`pyproject.toml`, the rewritten `[[package]]` unit and the
+  appended `[manifest]` / `[package.metadata]` fragments, plus their revert),
+  and the hosted `[tool.uv.sources]` edit renders as a header after
+  `[project]` the way uv writes it. (#238, #239)
+- **uv `--locked` survives the project shapes the plain fixture never
+  reached.** A package listed only in `[tool.uv] dev-dependencies` is now
+  classified as a direct dependency (it was wired as a transitive override
+  and its `requires-dev` entry left stale), and every duplicate
+  `requires-dist` / `requires-dev` entry for the package — extras, markers —
+  is repointed rather than only the first, so `uv sync --locked` and
+  `uv lock --check` accept the patched lock instead of exiting 2 and a plain
+  `uv sync` no longer rewrites it. `[tool.uv] constraint-dependencies` /
+  `build-constraint-dependencies` naming the package have their `[manifest]`
+  `constraints` / `build-constraints` entries repointed too (uv ≥ 0.5.6
+  serializes them with the package's source; 0.2.37–0.5.3 reject the
+  repointed entry under `--locked`, so the repoint emits the advisory
+  `pypi_uv_constraints_require_uv_0_5_6`). The transitive
+  (override-dependencies) branch emits the advisory
+  `pypi_uv_override_requires_uv_0_5_6`: uv applies `[tool.uv.sources]` to
+  overrides only from 0.5.6, so on 0.2.35–0.5.3 `--frozen` installs the
+  patch but a plain `uv sync` reinstalls the registry wheel. The
+  `[[distribution]]`-grammar vendoring refusal now names the real reasons
+  (relative path sources unparseable through 0.2.6, rejected by `--locked`
+  and absolutized by `uv lock` / `uv sync` on 0.2.17–0.2.34) instead of
+  "records absolute paths". `scripts/backtest-uv.py` gains a project-variant
+  lane covering these shapes on every `[[package]]` binary and a
+  `--render-doc-table` mode that prints the doc's results tables from
+  `results.json`; its export lane reads `uv export` from stdout because
+  `--output-file` only exists from 0.4.7. (#239)
+- **Unwired Python vendor entries revert safely.** `vendor --revert` /
+  `rollback` on a ledger entry without wiring to replay (the shape `repair`
+  reconstructs) skips the lock-reference guard under `--preserve-state`
+  (nothing is deleted, so nothing needs protecting), refuses fail-closed when
+  the project root cannot be listed or a lock's symlink target cannot be
+  read (instead of treating "could not enumerate locks" as "no lock
+  references it" and deleting the wheel), probes `-r` / `--requirement`
+  includes of `requirements.txt` alongside the root file — the orphan sweep
+  and `repair` see include-hosted pins too — and reclaims a genuinely
+  orphaned artifact directory whose lock is gone or whose ledger flavor is
+  unknown instead of failing forever. Hosted `scan` / `get`, `repair`, and
+  ledger-less `rollback` read candidate lockfiles through the FIFO-safe
+  reader, so a named pipe at a lockfile name no longer wedges the command in
+  `open(2)`. (#239)
+
 - **Path targeting on `scan` and `rollback`.** `scan [PATHS]...` scopes
   discovery to packages with an installed copy under a matching glob
   (ancestor rule: `scan packages/foo` covers the subtree; `*` never crosses
diff --git a/crates/socket-patch-cli/src/commands/repair_vendor.rs b/crates/socket-patch-cli/src/commands/repair_vendor.rs
index 3445d40b..be72ca41 100644
--- a/crates/socket-patch-cli/src/commands/repair_vendor.rs
+++ b/crates/socket-patch-cli/src/commands/repair_vendor.rs
@@ -15,9 +15,9 @@
 //! from the lockfile path itself (the contract's uuid-in-path rule), the
 //! record from the manifest (or the patch API, yielding a detached entry),
 //! and a fresh ledger entry is re-synthesized so sweep/GC/revert know the
-//! artifact again — stamped with the npm lockfile FLAVOR the reference was
-//! found in, so a later `vendor --revert` routes to the backend whose
-//! unwired-revert guard probes the right lockfile. WIRING reconstruction is
+//! artifact again — stamped with the lockfile FLAVOR the reference was
+//! found in (npm family and pypi), so a later `vendor --revert` routes to the
+//! backend whose unwired-revert guard probes the right lockfile. WIRING reconstruction is
 //! per-ecosystem: gem recognizes
 //! its own Gemfile/lock wiring and rebuilds full revert-capable records
 //! ([`socket_patch_core::vendor::gem::reconstruct_gem_wiring`]); the other
@@ -55,6 +55,7 @@ use socket_patch_core::api::client::{get_api_client_with_overrides, ApiClient};
 use socket_patch_core::crawlers::CrawlerOptions;
 use socket_patch_core::manifest::schema::{PatchManifest, PatchRecord};
 use socket_patch_core::patch::copy_tree::remove_tree;
+use socket_patch_core::utils::fs::read_regular_to_string;
 use socket_patch_core::utils::purl::{
     normalize_purl, percent_decode_purl_component, strip_purl_qualifiers,
 };
@@ -98,6 +99,8 @@ struct Candidate {
 
 /// Files the vendor backends rewire — the search space for
 /// `.socket/vendor/<eco>/<uuid>/<leaf>` references when the ledger is gone.
+/// The Python locks the root LISTS (`pylock*.toml`, `*.py.lock` + script)
+/// and the requirements `-r` include tree are appended at scan time.
 const WIRING_FILES: &[&str] = &[
     "package-lock.json",
     "npm-shrinkwrap.json",
@@ -143,10 +146,23 @@ pub(crate) async fn scan_vendor_references(project_root: &Path) -> Vec<(String,
             files.push(path);
         }
     }
+    // The requirements planner writes a vendored pin where the original pin
+    // was — possibly inside a `-r` include — so the root requirements.txt
+    // alone would miss it (and the orphan sweep, which reuses this scan,
+    // would delete the include-referenced wheel). An unreadable include
+    // tree degrades to the root file, matching the per-file tolerance
+    // below.
+    if let Ok(includes) =
+        socket_patch_core::vendor::requirements_include_names(project_root).await
+    {
+        files.extend(includes);
+    }
     files.sort();
     files.dedup();
     for file in files {
-        let Ok(text) = tokio::fs::read_to_string(project_root.join(file)).await else {
+        // FIFO-safe: a pipe under a wiring-file name must be skipped, not
+        // waited on forever in open(2).
+        let Ok(text) = read_regular_to_string(&project_root.join(file)).await else {
             continue;
         };
         let mut rest = text.as_str();
@@ -221,8 +237,14 @@ fn synth_entry(eco: &str, uuid: &str, artifact_path: &str, base_purl: &str) -> V
 async fn detect_reference_flavor(project_root: &Path, eco: &str, uuid: &str) -> Option<String> {
     if eco == "pypi" {
         let needle = format!(".socket/vendor/pypi/{uuid}/");
-        for file in socket_patch_core::utils::python_lock::python_lock_paths(project_root).ok()? {
-            if tokio::fs::read_to_string(project_root.join(&file))
+        let mut files =
+            socket_patch_core::utils::python_lock::python_lock_paths(project_root).ok()?;
+        // uv.lock outranks the standalone locks (the vendor backend's own
+        // precedence): a pylock EXPORTED from the wired project lock must not
+        // relabel the entry `python-lock`. Alphabetical order would.
+        files.sort_by_key(|file| file != "uv.lock");
+        for file in files {
+            if read_regular_to_string(&project_root.join(&file))
                 .await
                 .ok()
                 .is_some_and(|text| text.contains(&needle))
@@ -244,7 +266,7 @@ async fn detect_reference_flavor(project_root: &Path, eco: &str, uuid: &str) ->
     }
     let needle = format!(".socket/vendor/npm/{uuid}/");
     let read = |name: &'static str| async move {
-        tokio::fs::read_to_string(project_root.join(name))
+        read_regular_to_string(&project_root.join(name))
             .await
             .ok()
     };
@@ -1446,6 +1468,96 @@ fn npm_coords(base_purl: &str) -> Option<(String, String)> {
 mod tests {
     use super::*;
 
+    /// A FIFO under a wiring-file name (here the paired `<script>.py` of a
+    /// `*.py.lock`, which the lister cannot filter because it derives the
+    /// script name without stat'ing it) used to wedge `repair` forever: a
+    /// plain `read_to_string` blocks in open(2) waiting for a writer. Every
+    /// reference read must go through the FIFO-safe reader and skip it.
+    #[cfg(unix)]
+    #[tokio::test]
+    async fn repair_returns_with_fifo_script() {
+        use std::time::Duration;
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        let uuid = "11111111-1111-4111-8111-111111111111";
+        let path = format!(".socket/vendor/pypi/{uuid}/requests-2.28.1-py3-none-any.whl");
+        tokio::fs::write(
+            root.join("tool.py.lock"),
+            format!("archive = {{ path = '{path}' }}"),
+        )
+        .await
+        .unwrap();
+        let fifos = ["tool.py", "bun.lock"];
+        for name in fifos {
+            let c = std::ffi::CString::new(root.join(name).to_str().unwrap()).unwrap();
+            assert_eq!(unsafe { libc::mkfifo(c.as_ptr(), 0o644) }, 0, "mkfifo {name}");
+        }
+        // Release valve: if a read DID wedge in open(2), connecting a
+        // writer lets the blocking thread finish so the runtime can shut
+        // down and the test fails on the timeout instead of hanging.
+        let release = || {
+            use std::os::unix::fs::OpenOptionsExt as _;
+            for name in fifos {
+                let _ = std::fs::OpenOptions::new()
+                    .write(true)
+                    .custom_flags(libc::O_NONBLOCK)
+                    .open(root.join(name));
+            }
+        };
+
+        let scanned =
+            tokio::time::timeout(Duration::from_secs(5), scan_vendor_references(root)).await;
+        release();
+        let refs = scanned.expect("scan_vendor_references must not wedge on a FIFO script");
+        assert_eq!(
+            refs,
+            vec![("pypi".to_string(), uuid.to_string(), path.clone())],
+            "the lock reference is still recovered around the FIFO"
+        );
+
+        let flavor = tokio::time::timeout(
+            Duration::from_secs(5),
+            detect_reference_flavor(root, "npm", uuid),
+        )
+        .await;
+        release();
+        assert_eq!(
+            flavor.expect("detect_reference_flavor must not wedge on a FIFO lock"),
+            None
+        );
+    }
+
+    /// The requirements planner writes vendored pins into `-r` includes,
+    /// so a reference may live ONLY in an include. The scan used to read
+    /// the root requirements.txt alone, leaving such a wheel unrecoverable
+    /// by `repair` and deletable by the orphan sweep.
+    #[tokio::test]
+    async fn scan_recovers_include_hosted_requirements_reference() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        let uuid = "11111111-1111-4111-8111-111111111111";
+        let path = format!(".socket/vendor/pypi/{uuid}/six-1.16.0-py2.py3-none-any.whl");
+        tokio::fs::write(root.join("requirements.txt"), "-r requirements/base.txt\n")
+            .await
+            .unwrap();
+        tokio::fs::create_dir(root.join("requirements")).await.unwrap();
+        tokio::fs::write(
+            root.join("requirements/base.txt"),
+            format!(
+                "./{path} --hash=sha256:{}  # socket-patch vendor: six==1.16.0\n",
+                "0".repeat(64)
+            ),
+        )
+        .await
+        .unwrap();
+        let refs = scan_vendor_references(root).await;
+        assert_eq!(
+            refs,
+            vec![("pypi".to_string(), uuid.to_string(), path)],
+            "{refs:?}"
+        );
+    }
+
     #[tokio::test]
     async fn scan_recovers_script_and_pep751_vendor_references() {
         let tmp = tempfile::tempdir().unwrap();
@@ -1462,7 +1574,7 @@ mod tests {
         let references = scan_vendor_references(tmp.path()).await;
         assert_eq!(
             references,
-            vec![("pypi".to_string(), uuid.to_string(), path)]
+            vec![("pypi".to_string(), uuid.to_string(), path.clone())]
         );
         assert_eq!(
             detect_reference_flavor(tmp.path(), "pypi", uuid)
@@ -1470,6 +1582,19 @@ mod tests {
                 .as_deref(),
             Some("python-lock")
         );
+        // The project lock outranks a pylock exported from it.
+        tokio::fs::write(
+            tmp.path().join("uv.lock"),
+            format!("version = 1\n\n[[package]]\nname = \"requests\"\nversion = \"2.28.1\"\nsource = {{ path = \"{path}\" }}\n"),
+        )
+        .await
+        .unwrap();
+        assert_eq!(
+            detect_reference_flavor(tmp.path(), "pypi", uuid)
+                .await
+                .as_deref(),
+            Some("uv")
+        );
     }
 
     /// pnpm writes vendored paths in THREE spellings — override values,
diff --git a/crates/socket-patch-cli/src/commands/scan/hosted.rs b/crates/socket-patch-cli/src/commands/scan/hosted.rs
index 3a0028ef..7884d184 100644
--- a/crates/socket-patch-cli/src/commands/scan/hosted.rs
+++ b/crates/socket-patch-cli/src/commands/scan/hosted.rs
@@ -209,8 +209,12 @@ fn pnpm_trust_workspace_unreadable_detail(server: &str, err: &std::io::Error) ->
 /// present-but-unreadable workspace file was planned as a Create and
 /// OVERWRITTEN with the root-only scaffold, destroying the user's
 /// `packages:` globs.
+///
+/// FIFO-safe (`read_regular_to_string_sync`: non-blocking open + fstat): a
+/// FIFO planted at the path classifies as unreadable (`InvalidInput`) instead
+/// of wedging the run in `open(2)`.
 fn read_workspace_for_trust(path: &std::path::Path) -> std::io::Result<Option<String>> {
-    match std::fs::read_to_string(path) {
+    match socket_patch_core::utils::fs::read_regular_to_string_sync(path) {
         Ok(text) => Ok(Some(text)),
         Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(None),
         Err(e) => Err(e),
@@ -343,9 +347,23 @@ fn plan_workspace_trust(existing: Option<&str>) -> TrustPlan {
 /// in JSON mode today) the bare envelope is emitted. A `--json` consumer must
 /// always get parseable stdout — never empty output plus an exit code.
 fn emit_json_error(scan_result: Option<serde_json::Value>, message: &str) {
+    emit_json_error_with_code(scan_result, None, message);
+}
+
+/// `emit_json_error` plus an additive top-level `errorCode` (the stable
+/// routing tag the CLI contract gives every classified failure) when the
+/// refusal has one; `error` stays the human message.
+fn emit_json_error_with_code(
+    scan_result: Option<serde_json::Value>,
+    code: Option<&str>,
+    message: &str,
+) {
     let mut result = scan_result.unwrap_or_else(|| serde_json::json!({ "status": "error" }));
     result["status"] = serde_json::json!("error");
     result["error"] = serde_json::json!(message);
+    if let Some(code) = code {
+        result["errorCode"] = serde_json::json!(code);
+    }
     if !result.get("redirect").is_some_and(|r| r.is_object()) {
         result["redirect"] = serde_json::json!({ "mode": "hosted" });
     }
@@ -1253,10 +1271,17 @@ pub(crate) async fn run_redirect_selected(
         }
     }
 
-    // Read the project's candidate files, run the rewriters.
+    // Read the project's candidate files, run the rewriters. Every read goes
+    // through the FIFO-safe reader (non-blocking open + fstat regular-file
+    // check): a FIFO planted under any candidate name — pyproject.toml,
+    // uv.lock, a paired script, a rush lock — wedged `scan`/`get --mode
+    // hosted` forever in a plain `read_to_string` open(2) waiting for a
+    // writer. A non-regular file now reads as "unreadable" and is skipped
+    // exactly like a missing one.
+    use socket_patch_core::utils::fs::read_regular_to_string;
     let mut files: std::collections::BTreeMap<String, String> = std::collections::BTreeMap::new();
     for name in REDIRECT_CANDIDATE_FILES {
-        if let Ok(content) = std::fs::read_to_string(common.cwd.join(name)) {
+        if let Ok(content) = read_regular_to_string(&common.cwd.join(name)).await {
             files.insert((*name).to_string(), content);
         }
     }
@@ -1267,11 +1292,12 @@ pub(crate) async fn run_redirect_selected(
                 .strip_suffix(".py.lock")
                 .map(|prefix| format!("{prefix}.py"))
             {
-                if let Ok(content) = std::fs::read_to_string(common.cwd.join(&script_path)) {
+                if let Ok(content) = read_regular_to_string(&common.cwd.join(&script_path)).await
+                {
                     files.insert(script_path, content);
                 }
             }
-            if let Ok(content) = std::fs::read_to_string(common.cwd.join(&path)) {
+            if let Ok(content) = read_regular_to_string(&common.cwd.join(&path)).await {
                 files.insert(path, content);
             }
         }
@@ -1287,7 +1313,7 @@ pub(crate) async fn run_redirect_selected(
     let mut rush_lock_keys: Vec<String> = Vec::new();
     if common.cwd.join("rush.json").is_file() {
         let common_lock = socket_patch_core::constants::npm_family::RUSH_COMMON_LOCK_REL;
-        if let Ok(content) = std::fs::read_to_string(common.cwd.join(common_lock)) {
+        if let Ok(content) = read_regular_to_string(&common.cwd.join(common_lock)).await {
             files.insert(common_lock.to_string(), content);
             rush_lock_keys.push(common_lock.to_string());
         }
@@ -1305,7 +1331,7 @@ pub(crate) async fn run_redirect_selected(
                     continue;
                 };
                 let key = format!("common/config/subspaces/{name}/pnpm-lock.yaml");
-                if let Ok(content) = std::fs::read_to_string(dir.join("pnpm-lock.yaml")) {
+                if let Ok(content) = read_regular_to_string(&dir.join("pnpm-lock.yaml")).await {
                     files.insert(key.clone(), content);
                     rush_lock_keys.push(key);
                 }
@@ -1699,6 +1725,41 @@ pub(crate) async fn run_redirect_selected(
     let mut records: std::collections::BTreeMap<String, PatchRecord> =
         std::collections::BTreeMap::new();
     let mut record_warnings: Vec<serde_json::Value> = Vec::new();
+
+    // SYMLINK GUARD — fail-closed, whole rewrite, before the ledger and before
+    // any write (hosted rewrites are transactional). The writer below stages
+    // next to the path and renames over it, which REPLACES a symbolic link
+    // with a detached regular copy: the link target goes stale (uv itself
+    // writes THROUGH a linked uv.lock/pylock/pyproject), and `--revert`
+    // restores bytes but never the link (git shows a 120000→100644
+    // typechange). Since Python lock discovery follows links, a shared
+    // symlinked lock reaches this point as an ordinary rewrite target; the
+    // revert side (replay.rs) already refuses linked files, so the write
+    // side must too. Applies to every ecosystem's files (a symlinked
+    // package-lock.json has the same defect) and to dry runs, so a dry run
+    // predicts the refusal instead of a rewrite that will never happen.
+    if let Some(linked) = socket_patch_core::utils::fs::first_symlink(
+        &common.cwd,
+        rewrite.files.keys().map(String::as_str),
+    )
+    .await
+    {
+        let message = format!(
+            "{linked} is a symbolic link; socket-patch rewrites files in place with an atomic \
+             rename, which would replace the link — replace the link with a regular file (or \
+             run socket-patch in the directory it points to) and re-run; nothing was written"
+        );
+        eprintln!("Error (redirect_symlinked_file_unsupported): {message}");
+        if common.json {
+            emit_json_error_with_code(
+                scan_result.take(),
+                Some("redirect_symlinked_file_unsupported"),
+                &message,
+            );
+        }
+        return 1;
+    }
+
     if !common.dry_run {
         for (purl, uuid) in &confirmed {
             match api_client.fetch_patch(effective_org_slug, uuid).await {
diff --git a/crates/socket-patch-cli/src/commands/vendor.rs b/crates/socket-patch-cli/src/commands/vendor.rs
index a16603de..7c896751 100644
--- a/crates/socket-patch-cli/src/commands/vendor.rs
+++ b/crates/socket-patch-cli/src/commands/vendor.rs
@@ -2731,6 +2731,53 @@ mod gc_tests {
         assert!(!manifest.patches.contains_key(PURL), "{manifest:?}");
     }
 
+    /// The orphan sweep keeps every un-ledgered dir a project file still
+    /// points at. A vendored requirements pin may live ONLY in a `-r`
+    /// include (the planner writes it where the original pin was), and
+    /// the sweep used to consult the root requirements.txt alone — so
+    /// after a state.json loss it deleted the include-referenced wheel as
+    /// `vendor_orphan_removed` and bricked the next `pip install`.
+    #[tokio::test]
+    async fn orphan_sweep_keeps_include_referenced_dir() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        let uuid = "1a2b3c4d-5e6f-4a1b-8c2d-9e0f1a2b3c4d";
+        let rel_wheel = format!(".socket/vendor/pypi/{uuid}/six-1.16.0-py2.py3-none-any.whl");
+        let wheel = root.join(&rel_wheel);
+        tokio::fs::create_dir_all(wheel.parent().unwrap())
+            .await
+            .unwrap();
+        tokio::fs::write(&wheel, b"wheel bytes").await.unwrap();
+        tokio::fs::write(root.join("requirements.txt"), "-r requirements/base.txt\n")
+            .await
+            .unwrap();
+        tokio::fs::create_dir(root.join("requirements")).await.unwrap();
+        tokio::fs::write(
+            root.join("requirements/base.txt"),
+            format!(
+                "./{rel_wheel} --hash=sha256:{}  # socket-patch vendor: six==1.16.0\n",
+                "0".repeat(64)
+            ),
+        )
+        .await
+        .unwrap();
+
+        let sweep = sweep_orphan_vendor_dirs(root, &VendorState::default(), false).await;
+        assert_eq!(sweep.still_wired.len(), 1, "{:?}", sweep.still_wired);
+        assert_eq!(sweep.still_wired[0].uuid, uuid);
+        assert!(sweep.removed.is_empty(), "{:?}", sweep.removed);
+        assert!(wheel.is_file(), "the include-referenced wheel must survive");
+
+        // Drop the include reference: the dir is a true orphan now.
+        tokio::fs::write(root.join("requirements/base.txt"), "six==1.16.0\n")
+            .await
+            .unwrap();
+        let sweep = sweep_orphan_vendor_dirs(root, &VendorState::default(), false).await;
+        assert_eq!(sweep.removed.len(), 1, "{:?}", sweep.removed);
+        assert!(sweep.still_wired.is_empty());
+        assert!(!wheel.exists(), "the unreferenced orphan is reclaimed");
+    }
+
     /// (c) uuid dirs with no owning ledger entry are swept (wet) / counted
     /// (dry).
     #[tokio::test]
diff --git a/crates/socket-patch-cli/tests/hosted_symlinked_files.rs b/crates/socket-patch-cli/tests/hosted_symlinked_files.rs
new file mode 100644
index 00000000..7bf241a0
--- /dev/null
+++ b/crates/socket-patch-cli/tests/hosted_symlinked_files.rs
@@ -0,0 +1,543 @@
+//! `scan --mode hosted` against project files that are NOT plain regular
+//! files: symbolic links and FIFOs.
+//!
+//! Policy (PR #239 review): symlinked project files are DISCOVERED (the
+//! Python lock discovery follows links) but never REWRITTEN in place — every
+//! writer stages a replacement next to the path and renames over it, which
+//! replaces the link with a detached regular copy, leaves the link target
+//! stale (uv itself writes THROUGH the link) and makes a later revert
+//! restore bytes but never the link (git: a 120000→100644 typechange). The
+//! hosted REVERT side already refuses symlinked files fail-closed; these
+//! tests pin the WRITE side to the same policy: the whole (transactional)
+//! rewrite is refused with a stable code, before the ledger and before any
+//! file write.
+//!
+//! A FIFO planted under a candidate name (`pyproject.toml`) must be skipped
+//! like an unreadable file, never opened with a blocking `open(2)` that waits
+//! for a writer forever.
+//!
+//! Everything runs the built binary as a subprocess via
+//! `common::run_with_env` (hermetic `SOCKET_*` scrub) against a wiremock
+//! patch API, so the JSON envelope and the human stderr can both be read.
+
+#![cfg(unix)]
+
+use std::path::Path;
+
+use serde_json::{json, Value};
+use wiremock::matchers::{method, path, path_regex};
+use wiremock::{Mock, MockServer, ResponseTemplate};
+
+#[path = "common/mod.rs"]
+mod common;
+
+const ORG: &str = "test-org";
+const CODE: &str = "redirect_symlinked_file_unsupported";
+const LEDGER_REL: &str = ".socket/vendor/redirect-state.json";
+
+// npm fixture (the covgap hosted shape).
+const NPM_NAME: &str = "symlink-hosted";
+const NPM_VERSION: &str = "1.0.0";
+const NPM_PURL: &str = "pkg:npm/symlink-hosted@1.0.0";
+const NPM_UUID: &str = "11111111-1111-4111-8111-111111111111";
+const NPM_HOSTED_URL: &str = "http://patch.test/patch/npm/symlink-hosted/1.0.0/22222222-2222-4222-8222-222222222222/11111111-1111-4111-8111-111111111111/symlink-hosted-1.0.0.tgz";
+const PATCHED_SHA512: &str = "sha512-PATCHEDpatchedPATCHEDpatched0123456789==";
+const UPSTREAM_SHA512: &str = "sha512-UPSTREAMupstream==";
+
+// pypi fixture: the real `uv lock` output of uv 0.12.15 for a project
+// depending on `urllib3==1.26.18` (the public free-tier patch target).
+const PYPI_NAME: &str = "urllib3";
+const PYPI_VERSION: &str = "1.26.18";
+const PYPI_PURL: &str = "pkg:pypi/urllib3@1.26.18";
+const PYPI_UUID: &str = "33333333-3333-4333-8333-333333333333";
+const PYPROJECT: &str = "[project]\nname = \"socket-uv-patch-fixture\"\nversion = \"0.1.0\"\nrequires-python = \">=3.9\"\ndependencies = [\"urllib3==1.26.18\"]\n";
+const UV_LOCK: &str = r#"version = 1
+revision = 3
+requires-python = ">=3.9"
+
+[[package]]
+name = "socket-uv-patch-fixture"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "urllib3" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "urllib3", specifier = "==1.26.18" }]
+
+[[package]]
+name = "urllib3"
+version = "1.26.18"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0c/39/64487bf07df2ed854cc06078c27c0d0abc59bd27b32232876e403c333a08/urllib3-1.26.18.tar.gz", hash = "sha256:f8ecc1bba5667413457c529ab955bf8c67b45db799d159066261719e328580a0", size = 305687, upload-time = "2023-10-17T17:47:03.986Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b0/53/aa91e163dcfd1e5b82d8a890ecf13314e3e149c05270cc644581f77f17fd/urllib3-1.26.18-py2.py3-none-any.whl", hash = "sha256:34b97092d7e0a3a8cf7cd10e386f401b3737364026c45e622aa02903dffe0f07", size = 143835, upload-time = "2023-10-17T17:47:01.725Z" },
+]
+"#;
+
+// ───────────────────────────── API mocks ─────────────────────────────
+
+/// Batch discovery + per-package search for one `(purl, uuid)` pair.
+async fn mock_discovery(server: &MockServer, purl: &str, uuid: &str) {
+    Mock::given(method("POST"))
+        .and(path(format!("/v0/orgs/{ORG}/patches/batch")))
+        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
+            "packages": [{
+                "purl": purl,
+                "patches": [{
+                    "uuid": uuid, "purl": purl, "tier": "free",
+                    "cveIds": [], "ghsaIds": [], "severity": "high",
+                    "title": "symlink hosted fixture"
+                }]
+            }],
+            "canAccessPaidPatches": false,
+        })))
+        .mount(server)
+        .await;
+    Mock::given(method("GET"))
+        .and(path_regex(format!(
+            "^/v0/orgs/{ORG}/patches/by-package/.+$"
+        )))
+        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
+            "patches": [{
+                "uuid": uuid, "purl": purl,
+                "publishedAt": "2024-01-01T00:00:00Z",
+                "description": "x", "license": "MIT", "tier": "free",
+                "vulnerabilities": {}
+            }],
+            "canAccessPaidPatches": false,
+        })))
+        .mount(server)
+        .await;
+    Mock::given(method("GET"))
+        .and(path(format!("/v0/orgs/{ORG}/patches/view/{uuid}")))
+        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
+            "uuid": uuid,
+            "purl": purl,
+            "publishedAt": "2024-01-01T00:00:00Z",
+            "files": {},
+            "vulnerabilities": {},
+            "description": "x", "license": "MIT", "tier": "free"
+        })))
+        .mount(server)
+        .await;
+}
+
+/// A granted reference whose single `tarball` artifact carries `integrity`.
+async fn mock_granted_reference(
+    server: &MockServer,
+    uuid: &str,
+    purl: &str,
+    url: &str,
+    integrity: Value,
+) {
+    Mock::given(method("POST"))
+        .and(path(format!("/v0/orgs/{ORG}/patches/package")))
+        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
+            "results": {
+                uuid: {
+                    "status": "granted",
+                    "url": url,
+                    "purl": purl,
+                    "artifacts": [{
+                        "kind": "tarball",
+                        "url": url,
+                        "integrity": integrity
+                    }],
+                    "registryOverride": null
+                }
+            }
+        })))
+        .mount(server)
+        .await;
+}
+
+/// A minimal but valid wheel: `<name>-<version>.dist-info/METADATA` with the
+/// three required core-metadata headers. Returns the bytes and their sha256.
+fn build_wheel(name: &str, version: &str) -> (Vec<u8>, String) {
+    use std::io::Write as _;
+    let mut buf = std::io::Cursor::new(Vec::new());
+    {
+        let mut writer = zip::ZipWriter::new(&mut buf);
+        let opts = zip::write::SimpleFileOptions::default()
+            .compression_method(zip::CompressionMethod::Stored);
+        writer
+            .start_file(format!("{name}-{version}.dist-info/METADATA"), opts)
+            .unwrap();
+        writer
+            .write_all(format!("Metadata-Version: 2.1\nName: {name}\nVersion: {version}\n\n").as_bytes())
+            .unwrap();
+        writer.finish().unwrap();
+    }
+    let bytes = buf.into_inner();
+    let sha = common::sha256_hex(&bytes);
+    (bytes, sha)
+}
+
+/// Serve the wheel at `/wheels/<file>` and return its full URL.
+async fn mock_wheel(server: &MockServer, file: &str, bytes: Vec<u8>) -> String {
+    Mock::given(method("GET"))
+        .and(path(format!("/wheels/{file}")))
+        .respond_with(ResponseTemplate::new(200).set_body_bytes(bytes))
+        .mount(server)
+        .await;
+    format!("{}/wheels/{file}", server.uri())
+}
+
+// ─────────────────────────── project fixtures ───────────────────────────
+
+/// npm project: package.json + installed node_modules copy + a
+/// lockfileVersion-3 package-lock.json resolving `name` upstream.
+fn write_npm_project(root: &Path) {
+    std::fs::create_dir_all(root).unwrap();
+    std::fs::write(
+        root.join("package.json"),
+        format!(
+            r#"{{ "name": "consumer", "version": "0.0.0", "dependencies": {{ "{NPM_NAME}": "{NPM_VERSION}" }} }}"#
+        ),
+    )
+    .unwrap();
+    let pkg = root.join("node_modules").join(NPM_NAME);
+    std::fs::create_dir_all(&pkg).unwrap();
+    std::fs::write(
+        pkg.join("package.json"),
+        format!(r#"{{ "name": "{NPM_NAME}", "version": "{NPM_VERSION}" }}"#),
+    )
+    .unwrap();
+    std::fs::write(
+        root.join("package-lock.json"),
+        format!(
+            r#"{{
+  "name": "consumer",
+  "version": "0.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {{
+    "": {{ "name": "consumer", "version": "0.0.0", "dependencies": {{ "{NPM_NAME}": "{NPM_VERSION}" }} }},
+    "node_modules/{NPM_NAME}": {{
+      "version": "{NPM_VERSION}",
+      "resolved": "https://registry.npmjs.org/{NPM_NAME}/-/{NPM_NAME}-{NPM_VERSION}.tgz",
+      "integrity": "{UPSTREAM_SHA512}"
+    }}
+  }}
+}}
+"#
+        ),
+    )
+    .unwrap();
+}
+
+/// uv project: pyproject.toml + the real 0.12.15 uv.lock + a fabricated
+/// `.venv` install the python crawler discovers (`<name>-<version>.dist-info`
+/// under the POSIX site-packages layout — this file is unix-only).
+fn write_uv_project(root: &Path) {
+    std::fs::create_dir_all(root).unwrap();
+    std::fs::write(root.join("pyproject.toml"), PYPROJECT).unwrap();
+    std::fs::write(root.join("uv.lock"), UV_LOCK).unwrap();
+    let site = root
+        .join(".venv")
+        .join("lib")
+        .join("python3.11")
+        .join("site-packages");
+    let dist = site.join(format!("{PYPI_NAME}-{PYPI_VERSION}.dist-info"));
+    std::fs::create_dir_all(&dist).unwrap();
+    std::fs::write(
+        dist.join("METADATA"),
+        format!("Metadata-Version: 2.1\nName: {PYPI_NAME}\nVersion: {PYPI_VERSION}\n"),
+    )
+    .unwrap();
+    std::fs::create_dir_all(site.join(PYPI_NAME)).unwrap();
+    std::fs::write(site.join(PYPI_NAME).join("__init__.py"), "# upstream\n").unwrap();
+}
+
+/// Move `<root>/<name>` to `<shared>/<name>` and leave a RELATIVE symlink in
+/// its place (the checked-in shared-lock layout). Returns the target path.
+fn symlink_away(root: &Path, shared: &Path, name: &str) -> std::path::PathBuf {
+    std::fs::create_dir_all(shared).unwrap();
+    let target = shared.join(name);
+    std::fs::rename(root.join(name), &target).unwrap();
+    let rel = format!("../{}/{name}", shared.file_name().unwrap().to_str().unwrap());
+    std::os::unix::fs::symlink(&rel, root.join(name)).unwrap();
+    assert!(is_symlink(&root.join(name)) && root.join(name).exists());
+    target
+}
+
+fn is_symlink(path: &Path) -> bool {
+    std::fs::symlink_metadata(path)
+        .map(|m| m.file_type().is_symlink())
+        .unwrap_or(false)
+}
+
+fn mkfifo(path: &Path) {
+    use std::os::unix::ffi::OsStrExt as _;
+    let c_path = std::ffi::CString::new(path.as_os_str().as_bytes()).unwrap();
+    let rc = unsafe { libc::mkfifo(c_path.as_ptr(), 0o644) };
+    assert_eq!(rc, 0, "mkfifo(2): {}", std::io::Error::last_os_error());
+}
+
+// ───────────────────────────── runners ─────────────────────────────
+
+fn scan_hosted(cwd: &Path, api_url: &str, extra: &[&str]) -> (i32, String, String) {
+    let cwd_s = cwd.to_str().unwrap().to_string();
+    let mut args = vec![
+        "scan",
+        "--mode",
+        "hosted",
+        "--yes",
+        "--cwd",
+        &cwd_s,
+        "--api-url",
+        api_url,
+        "--org",
+        ORG,
+        "--api-token",
+        "fake",
+    ];
+    args.extend_from_slice(extra);
+    common::run_with_env(cwd, &args, &[])
+}
+
+fn scan_hosted_json(cwd: &Path, api_url: &str) -> (i32, Value, String) {
+    let (code, stdout, stderr) = scan_hosted(cwd, api_url, &["--json"]);
+    let doc = serde_json::from_str(&stdout).unwrap_or_else(|e| {
+        panic!("stdout must be the JSON envelope ({e});\nstdout=\n{stdout}\nstderr=\n{stderr}")
+    });
+    (code, doc, stderr)
+}
+
+/// The shared refusal contract: exit 1, `status: error`, the stable code,
+/// the detail names the linked file, and NOTHING was written — the link is
+/// still a link, its target is byte-identical, no ledger exists.
+fn assert_refused_untouched(
+    code: i32,
+    doc: &Value,
+    root: &Path,
+    linked: &str,
+    target: &Path,
+    target_before: &[u8],
+) {
+    assert_eq!(code, 1, "a symlinked rewrite target must fail the run: {doc:#}");
+    assert_eq!(doc["status"], "error", "{doc:#}");
+    assert_eq!(doc["errorCode"], CODE, "{doc:#}");
+    let message = doc["error"].as_str().unwrap_or_else(|| panic!("{doc:#}"));
+    assert!(
+        message.contains(linked) && message.contains("symbolic link"),
+        "the error must name the linked file: {message}"
+    );
+    assert!(
+        message.contains("atomic rename") && message.contains("re-run"),
+        "the error must explain the rename-over hazard and the remedy: {message}"
+    );
+    assert!(
+        is_symlink(&root.join(linked)),
+        "{linked} must still be a symlink: a rename-over would have detached it"
+    );
+    assert_eq!(
+        std::fs::read(target).unwrap(),
+        target_before,
+        "the link target must stay byte-identical"
+    );
+    assert!(
+        !root.join(LEDGER_REL).exists(),
+        "a refused rewrite must not write a redirect ledger"
+    );
+}
+
+// ───────────────────────────── tests ─────────────────────────────
+
+/// uv project whose `uv.lock` is a symlink into a shared directory (the
+/// exact layout reproduced against uv 0.12.15: uv writes THROUGH the link,
+/// socket-patch's rename-over replaced it with a detached regular copy).
+/// The rewrite plan touches pyproject.toml (regular) AND uv.lock (link);
+/// the whole plan is refused before the ledger and before either write.
+#[tokio::test]
+async fn hosted_refuses_symlinked_lock_before_ledger_write() {
+    let server = MockServer::start().await;
+    mock_discovery(&server, PYPI_PURL, PYPI_UUID).await;
+    let (wheel, sha256) = build_wheel(PYPI_NAME, PYPI_VERSION);
+    let wheel_url = mock_wheel(
+        &server,
+        &format!("{PYPI_NAME}-{PYPI_VERSION}-py2.py3-none-any.whl"),
+        wheel,
+    )
+    .await;
+    mock_granted_reference(
+        &server,
+        PYPI_UUID,
+        PYPI_PURL,
+        &wheel_url,
+        json!({ "sha256": sha256 }),
+    )
+    .await;
+
+    let tmp = tempfile::tempdir().unwrap();
+    let root = tmp.path().join("proj");
+    write_uv_project(&root);
+    let target = symlink_away(&root, &tmp.path().join("shared"), "uv.lock");
+    let lock_before = std::fs::read(&target).unwrap();
+
+    let (code, doc, _stderr) = scan_hosted_json(&root, &server.uri());
+    assert_refused_untouched(code, &doc, &root, "uv.lock", &target, &lock_before);
+    assert_eq!(
+        std::fs::read_to_string(root.join("pyproject.toml")).unwrap(),
+        PYPROJECT,
+        "the regular sibling in the same plan must not be written either: hosted \
+         rewrites are transactional"
+    );
+    assert!(
+        !root.join(".socket").exists(),
+        "nothing under .socket/ may be created by a refused rewrite"
+    );
+}
+
+/// The same defect exists for every ecosystem: a symlinked package-lock.json
+/// is refused identically. The human (non-JSON) run prints the same code
+/// and message on stderr and leaves the tree untouched too.
+#[tokio::test]
+async fn hosted_refuses_symlinked_package_lock_before_ledger_write() {
+    let server = MockServer::start().await;
+    mock_discovery(&server, NPM_PURL, NPM_UUID).await;
+    mock_granted_reference(
+        &server,
+        NPM_UUID,
+        NPM_PURL,
+        NPM_HOSTED_URL,
+        json!({ "sha512": PATCHED_SHA512 }),
+    )
+    .await;
+
+    let tmp = tempfile::tempdir().unwrap();
+    let root = tmp.path().join("proj");
+    write_npm_project(&root);
+    let target = symlink_away(&root, &tmp.path().join("shared"), "package-lock.json");
+    let lock_before = std::fs::read(&target).unwrap();
+
+    let (code, doc, _stderr) = scan_hosted_json(&root, &server.uri());
+    assert_refused_untouched(
+        code,
+        &doc,
+        &root,
+        "package-lock.json",
+        &target,
+        &lock_before,
+    );
+
+    let (code, _stdout, stderr) = scan_hosted(&root, &server.uri(), &[]);
+    assert_eq!(code, 1, "human run must fail the same way:\n{stderr}");
+    assert!(
+        stderr.contains(CODE) && stderr.contains("package-lock.json is a symbolic link"),
+        "the human run must print the stable code and the linked file:\n{stderr}"
+    );
+    assert!(is_symlink(&root.join("package-lock.json")));
+    assert_eq!(std::fs::read(&target).unwrap(), lock_before);
+    assert!(!root.join(LEDGER_REL).exists());
+}
+
+/// Control: with the link replaced by a regular file the identical project
+/// redirects normally — the refusal is about the LINK, not the layout.
+#[tokio::test]
+async fn hosted_rewrites_the_same_lock_once_it_is_a_regular_file() {
+    let server = MockServer::start().await;
+    mock_discovery(&server, NPM_PURL, NPM_UUID).await;
+    mock_granted_reference(
+        &server,
+        NPM_UUID,
+        NPM_PURL,
+        NPM_HOSTED_URL,
+        json!({ "sha512": PATCHED_SHA512 }),
+    )
+    .await;
+
+    let tmp = tempfile::tempdir().unwrap();
+    let root = tmp.path().join("proj");
+    write_npm_project(&root);
+    let target = symlink_away(&root, &tmp.path().join("shared"), "package-lock.json");
+    std::fs::remove_file(root.join("package-lock.json")).unwrap();
+    std::fs::copy(&target, root.join("package-lock.json")).unwrap();
+
+    let (code, doc, stderr) = scan_hosted_json(&root, &server.uri());
+    assert_eq!(code, 0, "{doc:#}\n{stderr}");
+    assert_eq!(doc["redirect"]["redirected"], 1, "{doc:#}");
+    assert!(
+        std::fs::read_to_string(root.join("package-lock.json"))
+            .unwrap()
+            .contains(NPM_HOSTED_URL)
+    );
+    assert!(root.join(LEDGER_REL).exists());
+}
+
+/// A FIFO planted as `pyproject.toml` beside a real uv.lock: the candidate
+/// collection must SKIP it (like any unreadable candidate) and the scan must
+/// return. Before the fix the raw `read_to_string` wedged forever in
+/// `open(2)` waiting for a writer — reproduced for `scan --mode hosted` and
+/// `get --mode hosted`.
+#[tokio::test]
+async fn hosted_scan_returns_with_fifo_candidate() {
+    let server = MockServer::start().await;
+    mock_discovery(&server, PYPI_PURL, PYPI_UUID).await;
+    let (wheel, sha256) = build_wheel(PYPI_NAME, PYPI_VERSION);
+    let wheel_url = mock_wheel(
+        &server,
+        &format!("{PYPI_NAME}-{PYPI_VERSION}-py2.py3-none-any.whl"),
+        wheel,
+    )
+    .await;
+    mock_granted_reference(
+        &server,
+        PYPI_UUID,
+        PYPI_PURL,
+        &wheel_url,
+        json!({ "sha256": sha256 }),
+    )
+    .await;
+
+    let tmp = tempfile::tempdir().unwrap();
+    let root = tmp.path().join("proj");
+    write_uv_project(&root);
+    std::fs::remove_file(root.join("pyproject.toml")).unwrap();
+    let fifo = root.join("pyproject.toml");
+    mkfifo(&fifo);
+
+    let (tx, rx) = std::sync::mpsc::channel();
+    let api = server.uri();
+    let run_root = root.clone();
+    std::thread::spawn(move || {
+        let _ = tx.send(scan_hosted(&run_root, &api, &["--json"]));
+    });
+    // A healthy run finishes in seconds; a wedged one never returns. On
+    // timeout connect a writer to the FIFO so the wedged `open(2)` releases
+    // and the child exits, then FAIL — never hang the suite.
+    let deadline = std::time::Duration::from_secs(90);
+    let (code, stdout, stderr) = match rx.recv_timeout(deadline) {
+        Ok(result) => result,
+        Err(_) => {
+            use std::os::unix::fs::OpenOptionsExt as _;
+            let released = std::fs::OpenOptions::new()
+                .write(true)
+                .custom_flags(libc::O_NONBLOCK)
+                .open(&fifo)
+                .is_ok();
+            panic!(
+                "scan --mode hosted wedged on a FIFO pyproject.toml for {deadline:?} \
+                 (a reader was blocked in open(2): {released})"
+            );
+        }
+    };
+    assert!(
+        code == 0 || code == 1,
+        "the run must complete with a real exit status, got {code}:\n{stdout}\n{stderr}"
+    );
+    let doc: Value = serde_json::from_str(&stdout)
+        .unwrap_or_else(|e| panic!("JSON envelope expected ({e}):\n{stdout}\n{stderr}"));
+    assert!(
+        doc["status"] == "success" || doc["status"] == "error",
+        "{doc:#}"
+    );
+    // The FIFO itself is left in place (nothing ever wrote to that name).
+    let meta = std::fs::symlink_metadata(&fifo).unwrap();
+    assert!(
+        std::os::unix::fs::FileTypeExt::is_fifo(&meta.file_type()),
+        "the FIFO must not be replaced by a rewrite"
+    );
+}
diff --git a/crates/socket-patch-core/src/patch/redirect/mod.rs b/crates/socket-patch-core/src/patch/redirect/mod.rs
index d4c09aea..0b4952a9 100644
--- a/crates/socket-patch-core/src/patch/redirect/mod.rs
+++ b/crates/socket-patch-core/src/patch/redirect/mod.rs
@@ -2696,16 +2696,29 @@ fn rewrite_uv_lock(
         complete_python_lock_metadata, is_python_lock_name, rewrite_python_lock, ArtifactSource,
     };
 
-    for (path, original) in files.iter().filter(|(path, _)| is_python_lock_name(path)) {
+    let locks: Vec<(&String, &String)> = files
+        .iter()
+        .filter(|(path, _)| is_python_lock_name(path))
+        .collect();
+    if locks.is_empty() {
+        return;
+    }
+    // Intake gate ONCE per dep, not once per lock file: a project carrying
+    // uv.lock + pylock.toml + a script lock would otherwise repeat the same
+    // missing-integrity warning three times.
+    let mut usable: Vec<(&DepOverride, &str)> = Vec::new();
+    for dep in overrides.iter().filter(|dep| dep.ecosystem == "pypi") {
+        match dep.integrity.sha256.as_deref() {
+            Some(sha256) => usable.push((dep, sha256)),
+            None => result.warnings.push(RewriteWarning {
+                code: "redirect_uv_missing_sha256".into(),
+                detail: format!("{} has no sha256 integrity", dep.name),
+            }),
+        }
+    }
+    for (path, original) in locks {
         let mut content = original.clone();
-        for dep in overrides.iter().filter(|dep| dep.ecosystem == "pypi") {
-            let Some(sha256) = dep.integrity.sha256.as_deref() else {
-                result.warnings.push(RewriteWarning {
-                    code: "redirect_uv_missing_sha256".into(),
-                    detail: format!("{} has no sha256 integrity", dep.name),
-                });
-                continue;
-            };
+        for &(dep, sha256) in &usable {
             let rewritten = match rewrite_python_lock(
                 &content,
                 &dep.name,
@@ -13262,3 +13275,43 @@ packages:
         );
     }
 }
+
+#[cfg(test)]
+mod python_lock_warning_tests {
+    use super::*;
+
+    #[test]
+    fn missing_sha256_warns_once_across_python_lock_files() {
+        let dep = DepOverride {
+            ecosystem: "pypi".into(),
+            name: "requests".into(),
+            namespace: None,
+            version: "2.28.1".into(),
+            token: "11111111-1111-4111-8111-111111111111".into(),
+            patch_uuid: "22222222-2222-4222-8222-222222222222".into(),
+            artifact_url: "https://patch.socket.dev/requests-2.28.1-py3-none-any.whl".into(),
+            berry_zip_url: None,
+            registry_override: None,
+            integrity: Integrity::default(),
+        };
+        let files = BTreeMap::from([
+            ("uv.lock".to_string(), "version = 1\n".to_string()),
+            (
+                "pylock.toml".to_string(),
+                "lock-version = \"1.0\"\n".to_string(),
+            ),
+            ("tool.py.lock".to_string(), "version = 1\n".to_string()),
+        ]);
+        let result = rewrite_registry_redirect(&files, &[dep]);
+        assert!(result.files.is_empty() && result.edits.is_empty());
+        let codes: Vec<&str> = result.warnings.iter().map(|w| w.code.as_str()).collect();
+        assert_eq!(
+            codes
+                .iter()
+                .filter(|code| **code == "redirect_uv_missing_sha256")
+                .count(),
+            1,
+            "{codes:?}"
+        );
+    }
+}
diff --git a/crates/socket-patch-core/src/utils/fs.rs b/crates/socket-patch-core/src/utils/fs.rs
index f6f83b3b..e69ff91f 100644
--- a/crates/socket-patch-core/src/utils/fs.rs
+++ b/crates/socket-patch-core/src/utils/fs.rs
@@ -134,6 +134,82 @@ pub(crate) async fn open_regular_file(
     Ok((file, metadata))
 }
 
+/// Read a regular file to a `String` through [`open_regular_file`]: the
+/// FIFO-safe reader (non-blocking open, fstat regular-file check on the
+/// opened descriptor) that the ecosystem modules had each re-declared
+/// privately. Follows a symlink to a regular file; a FIFO, directory or
+/// socket fails fast with `InvalidInput` instead of wedging in open(2).
+/// `pub` so the CLI crate's raw `read_to_string` sites can share it.
+pub async fn read_regular_to_string(path: &Path) -> std::io::Result<String> {
+    use tokio::io::AsyncReadExt as _;
+
+    let (mut file, metadata) = open_regular_file(path).await?;
+    let mut content = String::with_capacity(metadata.len() as usize);
+    file.read_to_string(&mut content).await?;
+    Ok(content)
+}
+
+/// True when `path` ITSELF is a symbolic link (lstat; the link target is not
+/// consulted, so a dangling link is still `true`). Writers that stage a
+/// replacement next to `path` and rename over it would replace the link with
+/// a regular file (leaving the target stale) — they use this to refuse
+/// fail-closed before any write, mirroring the hosted replay guard.
+pub async fn is_symlink(path: &Path) -> bool {
+    tokio::fs::symlink_metadata(path)
+        .await
+        .map(|metadata| metadata.file_type().is_symlink())
+        .unwrap_or(false)
+}
+
+/// Blocking twin of [`read_regular_to_string`] for the few synchronous
+/// helpers that read project files (the hosted flow's pnpm-workspace probe):
+/// same non-blocking open + fstat regular-file check, so a FIFO planted at
+/// the path fails fast with `InvalidInput` instead of wedging in open(2).
+/// Every other error keeps its kind (`NotFound`, `PermissionDenied`,
+/// `InvalidData` from the UTF-8 decode) so callers can classify it.
+pub fn read_regular_to_string_sync(path: &Path) -> std::io::Result<String> {
+    use std::io::Read as _;
+
+    #[cfg(unix)]
+    let mut file = {
+        use std::os::unix::fs::OpenOptionsExt as _;
+        std::fs::OpenOptions::new()
+            .read(true)
+            .custom_flags(libc::O_NONBLOCK)
+            .open(path)?
+    };
+    #[cfg(not(unix))]
+    let mut file = std::fs::File::open(path)?;
+
+    let metadata = file.metadata()?;
+    if !metadata.is_file() {
+        return Err(std::io::Error::new(
+            std::io::ErrorKind::InvalidInput,
+            format!("{} is not a regular file", path.display()),
+        ));
+    }
+    let mut content = String::with_capacity(metadata.len() as usize);
+    file.read_to_string(&mut content)?;
+    Ok(content)
+}
+
+/// The first of `rels` (root-relative, in the caller's order) that is a
+/// symbolic link — see [`is_symlink`]. Rewriters that are about to
+/// stage-and-rename over a whole file set use this to refuse the entire set
+/// fail-closed before the first write; a missing path (a file the rewrite
+/// would CREATE) is not a link.
+pub async fn first_symlink<'a>(
+    root: &Path,
+    rels: impl IntoIterator<Item = &'a str>,
+) -> Option<&'a str> {
+    for rel in rels {
+        if is_symlink(&root.join(rel)).await {
+            return Some(rel);
+        }
+    }
+    None
+}
+
 /// Return the raw `FileType` for `entry`, swallowing stat errors.
 ///
 /// Use this instead of `entry_is_dir` when the caller needs to
@@ -775,4 +851,103 @@ mod tests {
         );
         assert!(!ft.is_dir(), "entry_file_type must not resolve the target");
     }
+
+    /// `read_regular_to_string_sync` keeps the error kinds its callers
+    /// classify on (absent vs. unreadable vs. undecodable) and follows a
+    /// symlink to a regular file like the async reader.
+    #[test]
+    fn read_regular_to_string_sync_classifies_like_the_async_reader() {
+        let tmp = tempfile::tempdir().unwrap();
+        let missing = read_regular_to_string_sync(&tmp.path().join("absent")).unwrap_err();
+        assert_eq!(missing.kind(), std::io::ErrorKind::NotFound);
+        let dir = read_regular_to_string_sync(tmp.path()).unwrap_err();
+        // Unix opens a directory read-only and the fstat check classifies it;
+        // Windows' CreateFileW refuses the open outright with
+        // ERROR_ACCESS_DENIED (PermissionDenied). Either way it is an error
+        // the callers skip, never a wedge.
+        #[cfg(unix)]
+        assert_eq!(dir.kind(), std::io::ErrorKind::InvalidInput, "{dir}");
+        #[cfg(not(unix))]
+        assert!(
+            matches!(
+                dir.kind(),
+                std::io::ErrorKind::InvalidInput | std::io::ErrorKind::PermissionDenied
+            ),
+            "{dir}"
+        );
+        let file = tmp.path().join("ok.txt");
+        std::fs::write(&file, "packages:\n").unwrap();
+        assert_eq!(read_regular_to_string_sync(&file).unwrap(), "packages:\n");
+        let invalid = tmp.path().join("bad.txt");
+        std::fs::write(&invalid, b"\xff\xfe").unwrap();
+        assert_eq!(
+            read_regular_to_string_sync(&invalid).unwrap_err().kind(),
+            std::io::ErrorKind::InvalidData
+        );
+        #[cfg(unix)]
+        {
+            let link = tmp.path().join("link.txt");
+            std::os::unix::fs::symlink("ok.txt", &link).unwrap();
+            assert_eq!(read_regular_to_string_sync(&link).unwrap(), "packages:\n");
+        }
+    }
+
+    /// A FIFO at the path must fail fast (`InvalidInput`), never block in
+    /// open(2) waiting for a writer.
+    #[cfg(unix)]
+    #[test]
+    fn read_regular_to_string_sync_rejects_a_fifo_without_blocking() {
+        use std::os::unix::ffi::OsStrExt as _;
+        let tmp = tempfile::tempdir().unwrap();
+        let fifo = tmp.path().join("pnpm-workspace.yaml");
+        let c_path = std::ffi::CString::new(fifo.as_os_str().as_bytes()).unwrap();
+        assert_eq!(unsafe { libc::mkfifo(c_path.as_ptr(), 0o644) }, 0);
+        let (tx, rx) = std::sync::mpsc::channel();
+        let probe = fifo.clone();
+        std::thread::spawn(move || {
+            let _ = tx.send(read_regular_to_string_sync(&probe).map_err(|e| e.kind()));
+        });
+        match rx.recv_timeout(std::time::Duration::from_secs(5)) {
+            Ok(result) => assert_eq!(result, Err(std::io::ErrorKind::InvalidInput)),
+            Err(_) => {
+                // Release the wedged opener so the suite can fail cleanly.
+                let _ = std::fs::OpenOptions::new().write(true).open(&fifo);
+                panic!("the sync reader wedged in open(2) on a FIFO");
+            }
+        }
+    }
+
+    /// `first_symlink` reports the first LINK in iteration order, treats
+    /// absent paths (files a rewrite would create) as non-links and does not
+    /// follow the link to judge its target.
+    #[cfg(unix)]
+    #[tokio::test]
+    async fn first_symlink_reports_links_in_caller_order() {
+        let tmp = tempfile::tempdir().unwrap();
+        std::fs::write(tmp.path().join("package-lock.json"), "{}").unwrap();
+        std::fs::write(tmp.path().join("real.lock"), "x").unwrap();
+        std::os::unix::fs::symlink("real.lock", tmp.path().join("uv.lock")).unwrap();
+        std::os::unix::fs::symlink("missing", tmp.path().join("dangling.lock")).unwrap();
+        assert_eq!(
+            first_symlink(
+                tmp.path(),
+                ["package-lock.json", "pnpm-workspace.yaml", "real.lock"]
+            )
+            .await,
+            None
+        );
+        assert_eq!(
+            first_symlink(
+                tmp.path(),
+                ["package-lock.json", "uv.lock", "dangling.lock"]
+            )
+            .await,
+            Some("uv.lock")
+        );
+        assert_eq!(
+            first_symlink(tmp.path(), ["dangling.lock", "uv.lock"]).await,
+            Some("dangling.lock"),
+            "a dangling link is still a link the rename would replace"
+        );
+    }
 }
diff --git a/crates/socket-patch-core/src/utils/python_lock.rs b/crates/socket-patch-core/src/utils/python_lock.rs
index 8bb4418b..2c37d798 100644
--- a/crates/socket-patch-core/src/utils/python_lock.rs
+++ b/crates/socket-patch-core/src/utils/python_lock.rs
@@ -36,21 +36,61 @@ pub fn is_python_lock_name(name: &str) -> bool {
 pub fn python_lock_paths(root: &Path) -> std::io::Result<Vec<String>> {
     let mut paths = Vec::new();
     for entry in std::fs::read_dir(root)? {
-        let entry = entry?;
-        if !entry.file_type()?.is_file() {
+        // One unreadable directory entry must not hide every other lock:
+        // the callers treat an `Err` as "no Python locks here", which would
+        // silently drop the whole project from inventory, repair, and the
+        // hosted candidate list.
+        let Ok(entry) = entry else {
             continue;
-        }
+        };
         let Some(name) = entry.file_name().to_str().map(str::to_string) else {
             continue;
         };
-        if is_python_lock_name(&name) {
-            paths.push(name);
+        if !is_python_lock_name(&name) {
+            continue;
         }
+        // `DirEntry::file_type` does NOT follow symlinks, so a lock that is a
+        // symlink (a shared pylock, a checked-in link) was never discovered
+        // even though every reader opens it fine. `fs::metadata` follows the
+        // link; a link to a directory or FIFO is still excluded by `is_file`.
+        if !std::fs::metadata(entry.path())
+            .map(|metadata| metadata.is_file())
+            .unwrap_or(false)
+        {
+            continue;
+        }
+        paths.push(name);
     }
     paths.sort();
     Ok(paths)
 }
 
+/// Re-apply the input's CRLF convention to a toml_edit rendering.
+///
+/// toml_edit (0.25.x) re-emits every newline as `\n`: a CRLF document comes
+/// back entirely LF even when nothing was edited, so a rewritten lock or
+/// pyproject would churn on every line under git and a byte-exact revert
+/// could never converge. When the input used CRLF exclusively, convert the
+/// rendering back; mixed-ending files are left as rendered rather than
+/// half-converted.
+pub fn preserve_line_endings(original: &str, rendered: String) -> String {
+    let uses_crlf = original.contains("\r\n");
+    let has_bare_lf = original.replace("\r\n", "").contains('\n');
+    if !uses_crlf || has_bare_lf {
+        return rendered;
+    }
+    let mut output = String::with_capacity(rendered.len() + rendered.matches('\n').count());
+    let mut previous = '\0';
+    for character in rendered.chars() {
+        if character == '\n' && previous != '\r' {
+            output.push('\r');
+        }
+        output.push(character);
+        previous = character;
+    }
+    output
+}
+
 fn inline(entries: &[(&str, Value)]) -> Value {
     let mut table = InlineTable::new();
     for (key, value) in entries {
@@ -180,6 +220,32 @@ fn rewrite_manifest(document: &mut DocumentMut, name: &str, artifact: ArtifactSo
     else {
         return;
     };
+    // `[tool.uv] constraint-dependencies` / `build-constraint-dependencies`
+    // land here as `{ name, specifier }`; uv >= 0.5.6 re-serializes a sourced
+    // package's element as `{ name, url|path }` (specifier dropped), so a
+    // stale specifier keeps `uv lock --check` / `uv sync --locked` at exit 2
+    // and a plain sync churns the lock. Repoint every matching element in
+    // both arrays, independent of the `requirements` key below (a project
+    // lock has none — only script locks do).
+    for key in ["constraints", "build-constraints"] {
+        if let Some(constraints) = manifest.get_mut(key).and_then(Item::as_array_mut) {
+            for constraint in constraints
+                .iter_mut()
+                .filter_map(Value::as_inline_table_mut)
+            {
+                if constraint
+                    .get("name")
+                    .and_then(Value::as_str)
+                    .is_some_and(|value| canonicalize_pypi_name(value) == name)
+                {
+                    constraint.remove("specifier");
+                    constraint.remove("url");
+                    constraint.remove("path");
+                    constraint.insert(artifact.key(), Value::from(artifact.location()));
+                }
+            }
+        }
+    }
     if !manifest.contains_key("requirements") {
         return;
     }
@@ -405,7 +471,7 @@ pub fn complete_python_lock_metadata(
             }
         }
     }
-    Ok(document.to_string())
+    Ok(preserve_line_endings(text, document.to_string()))
 }
 
 pub fn rewrite_python_lock(
@@ -465,6 +531,35 @@ pub fn rewrite_python_lock(
         .get_mut(*index)
         .expect("matching package index exists");
     let original_source = package.get("source").cloned();
+    // uv 0.2.18 through 0.2.34 kept the `[[distribution]]` table name but had
+    // already moved to inline-table sources (`source = { registry = … }`,
+    // `wheels = [{ … }]`, `dependencies = [{ name = … }]`). Those binaries
+    // reject the string grammar (`source = "direct+…"`, `[[distribution.wheel]]`)
+    // with "data did not match any variant of untagged enum SourceWire" and
+    // then IGNORE the lock: an ordinary `uv sync` re-resolves from the
+    // pyproject source (still the patch), but `--frozen` / `--locked` fail.
+    // Follow the entry's OWN source shape, not the table name.
+    let legacy_strings = legacy
+        && original_source
+            .as_ref()
+            .and_then(source_identity)
+            .is_some_and(|(kind, _)| kind == "legacy");
+    // The artifact shape flipped separately (at 0.2.5→0.2.6): uv 0.2.6–0.2.17
+    // still write string sources but already use inline `sdist = { … }` /
+    // `wheels = [ … ]` instead of the `[distribution.sdist]` /
+    // `[[distribution.wheel]]` tables of uv ≤0.2.5.
+    // uv 0.2.17 parses an unexpected `[[distribution.wheel]]` but ignores it,
+    // then treats the direct wheel URL as a source archive ("Unsupported
+    // archive type: …whl"). Decide from the entry's own artifact keys, then
+    // from any sibling entry in the document.
+    let legacy_artifact_tables = legacy
+        && (package.get("wheel").is_some_and(Item::is_array_of_tables)
+            || package.get("sdist").is_some_and(Item::is_table)
+            || (package.get("wheel").is_none()
+                && package.get("wheels").is_none()
+                && package.get("sdist").is_none()
+                && (text.contains("[[distribution.wheel]]")
+                    || text.contains("[distribution.sdist]"))));
     if !pep751
         && !original_source.as_ref().is_some_and(|source| {
             source_identity(source).is_some_and(|(kind, value)| {
@@ -511,11 +606,14 @@ pub fn rewrite_python_lock(
             ])),
         );
     } else {
-        let source = if legacy {
-            match artifact {
-                ArtifactSource::Url(_) => Item::Value(Value::from(format!("direct+{location}"))),
-                ArtifactSource::Path(_) => return Err("uv 0.1 lockfiles require absolute file URLs; portable vendoring needs uv >=0.2".to_string()),
-            }
+        let source = if legacy && matches!(artifact, ArtifactSource::Path(_)) {
+            // Both `[[distribution]]` shapes record ABSOLUTE paths/file URLs
+            // for local artifacts (uv 0.2.34 writes `source = { path = "/abs/…" }`
+            // and `wheels = [{ url = "file:///abs/…" }]`), so a committed
+            // relative wheel cannot be expressed portably before 0.2.35.
+            return Err("uv `[[distribution]]` lockfiles (uv < 0.2.35, experimental `uv lock`) cannot carry a portable local wheel: `--locked` rejects relative paths and `uv lock`/`uv sync` rewrite them to absolute ones; upgrade to uv >=0.2.35 for native vendoring, or use a requirements.txt installation".to_string());
+        } else if legacy_strings {
+            Item::Value(Value::from(format!("direct+{location}")))
         } else {
             Item::Value(inline(&[(artifact.key(), Value::from(location.clone()))]))
         };
@@ -534,7 +632,7 @@ pub fn rewrite_python_lock(
             (artifact_key, Value::from(artifact_location)),
             ("hash", Value::from(format!("sha256:{sha256}"))),
         ]);
-        if legacy && wheel {
+        if legacy_artifact_tables && wheel {
             let mut table = Table::new();
             table["url"] = toml_edit::value(artifact_location);
             table["hash"] = toml_edit::value(format!("sha256:{sha256}"));
@@ -545,6 +643,11 @@ pub fn rewrite_python_lock(
             let mut array = Array::new();
             array.push_formatted(entry);
             package.insert("wheels", Item::Value(Value::Array(array)));
+        } else if legacy_artifact_tables {
+            let mut table = Table::new();
+            table["url"] = toml_edit::value(artifact_location);
+            table["hash"] = toml_edit::value(format!("sha256:{sha256}"));
+            package.insert("sdist", Item::Table(table));
         } else {
             package.insert("sdist", Item::Value(entry));
         }
@@ -561,7 +664,7 @@ pub fn rewrite_python_lock(
     if !pep751 && !legacy {
         rewrite_manifest(&mut document, &name, artifact);
     }
-    Ok(Some(document.to_string()))
+    Ok(Some(preserve_line_endings(text, document.to_string())))
 }
 
 #[cfg(test)]
@@ -709,6 +812,321 @@ hash = "sha256:old"
         );
     }
 
+    /// uv 0.2.18–0.2.34 (`uv lock` as shipped): `[[distribution]]` tables
+    /// with INLINE-TABLE sources. Emitting the string grammar here made those
+    /// binaries reject the lock ("data did not match any variant of untagged
+    /// enum SourceWire") and re-resolve, so `--frozen` / `--locked` failed.
+    #[test]
+    fn hybrid_distribution_lock_keeps_inline_table_sources() {
+        let text = r#"version = 1
+requires-python = ">=3.9"
+
+[[distribution]]
+name = "socket-uv-patch-fixture"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+    { name = "urllib3" },
+]
+
+[[distribution]]
+name = "urllib3"
+version = "1.26.18"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/urllib3-1.26.18.tar.gz", hash = "sha256:old", size = 305687 }
+wheels = [
+    { url = "https://files.pythonhosted.org/urllib3-1.26.18-py2.py3-none-any.whl", hash = "sha256:old", size = 143835 },
+]
+"#;
+        let rewritten =
+            rewrite_python_lock(text, "urllib3", "1.26.18", ArtifactSource::Url(URL), SHA256)
+                .unwrap()
+                .unwrap();
+        assert!(rewritten.contains("[[distribution]]"), "{rewritten}");
+        assert!(
+            rewritten.contains(&format!("source = {{ url = \"{URL}\" }}")),
+            "{rewritten}"
+        );
+        assert!(
+            rewritten.contains(&format!("{{ url = \"{URL}\", hash = \"sha256:{SHA256}\" }}")),
+            "{rewritten}"
+        );
+        assert!(!rewritten.contains("direct+"), "{rewritten}");
+        assert!(!rewritten.contains("[[distribution.wheel]]"), "{rewritten}");
+        assert!(!rewritten.contains("sdist"), "{rewritten}");
+        assert!(!rewritten.contains("pythonhosted"), "{rewritten}");
+        // The root entry's edge and source are untouched; re-run is a no-op.
+        assert!(rewritten.contains("source = { editable = \".\" }"));
+        assert_eq!(
+            rewrite_python_lock(
+                &rewritten,
+                "urllib3",
+                "1.26.18",
+                ArtifactSource::Url(URL),
+                SHA256
+            )
+            .unwrap()
+            .unwrap(),
+            rewritten
+        );
+        // Vendoring stays refused for every `[[distribution]]` shape.
+        let refused = rewrite_python_lock(
+            text,
+            "urllib3",
+            "1.26.18",
+            ArtifactSource::Path(".socket/vendor/pypi/x/urllib3-1.26.18-py2.py3-none-any.whl"),
+            SHA256,
+        )
+        .unwrap_err();
+        assert!(refused.contains("0.2.35"), "{refused}");
+    }
+
+    /// uv 0.2.6–0.2.17: string sources, but INLINE `sdist = {…}` /
+    /// `wheels = [{…}]` artifacts. The bare `[[distribution.dependencies]]`
+    /// edge here is the 0.2.16–0.2.17 shape (0.2.6–0.2.15 still write
+    /// source-qualified edges, covered above). Emitting `[[distribution.wheel]]` here left the binary with a
+    /// direct URL and no wheel, which it tried to build as an sdist
+    /// ("Unsupported archive type: urllib3-….whl").
+    #[test]
+    fn string_source_inline_artifact_lock_keeps_inline_wheels() {
+        let text = r#"version = 1
+requires-python = ">=3.9"
+
+[[distribution]]
+name = "socket-uv-patch-fixture"
+version = "0.1.0"
+source = "editable+."
+
+[[distribution.dependencies]]
+name = "urllib3"
+
+[[distribution]]
+name = "urllib3"
+version = "1.26.18"
+source = "registry+https://pypi.org/simple"
+sdist = { url = "https://files.pythonhosted.org/urllib3-1.26.18.tar.gz", hash = "sha256:old", size = 305687 }
+wheels = [{ url = "https://files.pythonhosted.org/urllib3-1.26.18-py2.py3-none-any.whl", hash = "sha256:old", size = 143835 }]
+"#;
+        let rewritten =
+            rewrite_python_lock(text, "urllib3", "1.26.18", ArtifactSource::Url(URL), SHA256)
+                .unwrap()
+                .unwrap();
+        assert!(
+            rewritten.contains(&format!("source = \"direct+{URL}\"")),
+            "{rewritten}"
+        );
+        assert!(
+            rewritten.contains(&format!("wheels = [{{ url = \"{URL}\", hash = \"sha256:{SHA256}\" }}]")),
+            "{rewritten}"
+        );
+        assert!(!rewritten.contains("[[distribution.wheel]]"), "{rewritten}");
+        assert!(!rewritten.contains("sdist"), "{rewritten}");
+        assert!(rewritten.contains("[[distribution.dependencies]]\nname = \"urllib3\""), "{rewritten}");
+        assert_eq!(
+            rewrite_python_lock(
+                &rewritten,
+                "urllib3",
+                "1.26.18",
+                ArtifactSource::Url(URL),
+                SHA256
+            )
+            .unwrap()
+            .unwrap(),
+            rewritten
+        );
+    }
+
+    /// uv ≤0.2.5 (string sources + `[distribution.sdist]` /
+    /// `[[distribution.wheel]]` SUB-TABLES): a patch shipped as a source
+    /// archive must land in a `[distribution.sdist]` sub-table — not an
+    /// inline `sdist = { … }` those binaries never wrote — and the stale
+    /// `[[distribution.wheel]]` must go so the URL is not fetched twice.
+    #[test]
+    fn legacy_sdist_redirect_emits_sub_table() {
+        let text = r#"version = 1
+
+[[distribution]]
+name = "project"
+version = "1"
+source = "editable+."
+
+[[distribution.dependencies]]
+name = "urllib3"
+version = "1.26.18"
+source = "registry+https://pypi.org/simple"
+
+[[distribution]]
+name = "urllib3"
+version = "1.26.18"
+source = "registry+https://pypi.org/simple"
+
+[distribution.sdist]
+url = "https://files.pythonhosted.org/urllib3-1.26.18.tar.gz"
+hash = "sha256:old"
+size = 305687
+
+[[distribution.wheel]]
+url = "https://files.pythonhosted.org/urllib3-1.26.18-py2.py3-none-any.whl"
+hash = "sha256:old"
+size = 143835
+"#;
+        let url = "https://patch.socket.dev/pkg/urllib3-1.26.18.tar.gz";
+        let rewritten =
+            rewrite_python_lock(text, "urllib3", "1.26.18", ArtifactSource::Url(url), SHA256)
+                .unwrap()
+                .unwrap();
+        let document: toml_edit::DocumentMut = rewritten.parse().unwrap();
+        let target = document["distribution"]
+            .as_array_of_tables()
+            .unwrap()
+            .get(1)
+            .unwrap();
+        assert_eq!(target["source"].as_str(), Some(&*format!("direct+{url}")));
+        assert!(target["sdist"].is_table(), "{rewritten}");
+        assert_eq!(target["sdist"]["url"].as_str(), Some(url));
+        assert_eq!(
+            target["sdist"]["hash"].as_str(),
+            Some(&*format!("sha256:{SHA256}"))
+        );
+        assert!(target.get("wheel").is_none(), "{rewritten}");
+        assert!(target.get("wheels").is_none(), "{rewritten}");
+        assert!(rewritten.contains("[distribution.sdist]"), "{rewritten}");
+        assert!(!rewritten.contains("[[distribution.wheel]]"), "{rewritten}");
+        assert!(!rewritten.contains("sdist = {"), "{rewritten}");
+        assert!(!rewritten.contains("pythonhosted"), "{rewritten}");
+        assert!(!rewritten.contains("size = "), "{rewritten}");
+        // The source-qualified edge follows the new source.
+        assert_eq!(rewritten.matches(&format!("direct+{url}")).count(), 2);
+        assert!(!rewritten.contains("registry+"), "{rewritten}");
+        assert_eq!(
+            rewrite_python_lock(
+                &rewritten,
+                "urllib3",
+                "1.26.18",
+                ArtifactSource::Url(url),
+                SHA256
+            )
+            .unwrap()
+            .unwrap(),
+            rewritten
+        );
+    }
+
+    /// A `[[distribution]]` entry with no artifact keys of its own (uv wrote
+    /// none for an editable/directory-less registry entry it never fetched)
+    /// carries no evidence of the document's artifact grammar. The shape is
+    /// then taken from any SIBLING entry: `[[distribution.wheel]]` siblings
+    /// (≤0.2.5) → a `[[distribution.wheel]]` sub-table; inline `wheels = […]`
+    /// siblings (0.2.6–0.2.17) → an inline `wheels` array.
+    #[test]
+    fn artifactless_target_follows_sibling_shape() {
+        let target = r#"
+[[distribution]]
+name = "urllib3"
+version = "1.26.18"
+source = "registry+https://pypi.org/simple"
+"#;
+        let sub_table_sibling = format!(
+            r#"version = 1
+
+[[distribution]]
+name = "certifi"
+version = "2024.2.2"
+source = "registry+https://pypi.org/simple"
+
+[[distribution.wheel]]
+url = "https://files.pythonhosted.org/certifi-2024.2.2-py3-none-any.whl"
+hash = "sha256:certifi"
+{target}"#
+        );
+        let rewritten = rewrite_python_lock(
+            &sub_table_sibling,
+            "urllib3",
+            "1.26.18",
+            ArtifactSource::Url(URL),
+            SHA256,
+        )
+        .unwrap()
+        .unwrap();
+        let document: toml_edit::DocumentMut = rewritten.parse().unwrap();
+        let entry = document["distribution"]
+            .as_array_of_tables()
+            .unwrap()
+            .get(1)
+            .unwrap();
+        assert_eq!(entry["source"].as_str(), Some(&*format!("direct+{URL}")));
+        assert!(entry["wheel"].is_array_of_tables(), "{rewritten}");
+        assert_eq!(entry["wheel"][0]["url"].as_str(), Some(URL));
+        assert_eq!(
+            entry["wheel"][0]["hash"].as_str(),
+            Some(&*format!("sha256:{SHA256}"))
+        );
+        assert!(entry.get("wheels").is_none(), "{rewritten}");
+        assert_eq!(rewritten.matches("[[distribution.wheel]]").count(), 2, "{rewritten}");
+        assert!(!rewritten.contains("wheels = ["), "{rewritten}");
+        // The sibling's own artifact is untouched.
+        assert!(rewritten.contains("certifi-2024.2.2-py3-none-any.whl"));
+        assert_eq!(
+            rewrite_python_lock(
+                &rewritten,
+                "urllib3",
+                "1.26.18",
+                ArtifactSource::Url(URL),
+                SHA256
+            )
+            .unwrap()
+            .unwrap(),
+            rewritten
+        );
+
+        let inline_sibling = format!(
+            r#"version = 1
+
+[[distribution]]
+name = "certifi"
+version = "2024.2.2"
+source = "registry+https://pypi.org/simple"
+wheels = [{{ url = "https://files.pythonhosted.org/certifi-2024.2.2-py3-none-any.whl", hash = "sha256:certifi" }}]
+{target}"#
+        );
+        let rewritten = rewrite_python_lock(
+            &inline_sibling,
+            "urllib3",
+            "1.26.18",
+            ArtifactSource::Url(URL),
+            SHA256,
+        )
+        .unwrap()
+        .unwrap();
+        let document: toml_edit::DocumentMut = rewritten.parse().unwrap();
+        let entry = document["distribution"]
+            .as_array_of_tables()
+            .unwrap()
+            .get(1)
+            .unwrap();
+        assert_eq!(entry["source"].as_str(), Some(&*format!("direct+{URL}")));
+        assert!(entry["wheels"].is_array(), "{rewritten}");
+        assert_eq!(entry["wheels"][0]["url"].as_str(), Some(URL));
+        assert!(entry.get("wheel").is_none(), "{rewritten}");
+        assert!(
+            rewritten.contains(&format!("wheels = [{{ url = \"{URL}\", hash = \"sha256:{SHA256}\" }}]")),
+            "{rewritten}"
+        );
+        assert!(!rewritten.contains("[[distribution.wheel]]"), "{rewritten}");
+        assert_eq!(
+            rewrite_python_lock(
+                &rewritten,
+                "urllib3",
+                "1.26.18",
+                ArtifactSource::Url(URL),
+                SHA256
+            )
+            .unwrap()
+            .unwrap(),
+            rewritten
+        );
+    }
+
     #[test]
     fn pep751_replaces_registry_artifacts_with_one_archive() {
         let text = r#"lock-version = "1.0"
@@ -856,3 +1274,153 @@ wheels = [{url = "https://pypi.org/urllib3.whl", hashes = {sha256 = "old"}}]
         }
     }
 }
+
+#[cfg(test)]
+mod discovery_and_line_ending_tests {
+    use super::*;
+
+    #[test]
+    fn crlf_locks_keep_their_line_endings_through_a_rewrite() {
+        let lock = "lock-version = \"1.0\"\r\ncreated-by = \"uv\"\r\n\r\n[[packages]]\r\nname = \"requests\"\r\nversion = \"2.28.1\"\r\nwheels = [{ name = \"requests-2.28.1-py3-none-any.whl\", url = \"https://pypi.org/requests-2.28.1-py3-none-any.whl\", hashes = { sha256 = \"old\" } }]\r\n";
+        let url = "https://patch.socket.dev/requests-2.28.1-py3-none-any.whl";
+        let out = rewrite_python_lock(
+            lock,
+            "requests",
+            "2.28.1",
+            ArtifactSource::Url(url),
+            &"a".repeat(64),
+        )
+        .unwrap()
+        .expect("rewritten");
+        assert!(out.contains(url) && !out.contains("pypi.org"), "{out}");
+        assert!(!out.contains("\r\r"), "{out:?}");
+        assert_eq!(
+            out.matches("\r\n").count(),
+            out.matches('\n').count(),
+            "every newline must stay CRLF: {out:?}"
+        );
+        // Re-running over the CRLF output is byte-stable.
+        assert_eq!(
+            rewrite_python_lock(
+                &out,
+                "requests",
+                "2.28.1",
+                ArtifactSource::Url(url),
+                &"a".repeat(64)
+            )
+            .unwrap()
+            .as_deref(),
+            Some(out.as_str())
+        );
+    }
+
+    #[test]
+    fn line_endings_are_restored_only_for_pure_crlf_inputs() {
+        assert_eq!(
+            preserve_line_endings("a\r\nb\r\n", "a\nb\n".into()),
+            "a\r\nb\r\n"
+        );
+        assert_eq!(
+            preserve_line_endings("a\r\nb\nc", "a\nb\nc".into()),
+            "a\nb\nc"
+        );
+        assert_eq!(preserve_line_endings("a\nb\n", "a\nb\n".into()), "a\nb\n");
+        assert_eq!(
+            preserve_line_endings("a\r\n", "a\r\nb\n".into()),
+            "a\r\nb\r\n"
+        );
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn python_lock_paths_follow_symlinks_and_skip_non_files() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        std::fs::write(root.join("shared.toml"), "lock-version = \"1.0\"\n").unwrap();
+        std::os::unix::fs::symlink(root.join("shared.toml"), root.join("pylock.toml")).unwrap();
+        std::fs::write(root.join("tool.py.lock"), "version = 1\n").unwrap();
+        // A directory that merely carries a lock name, and a dangling link.
+        std::fs::create_dir(root.join("uv.lock")).unwrap();
+        std::os::unix::fs::symlink(root.join("missing"), root.join("pylock.dev.toml")).unwrap();
+        assert_eq!(
+            python_lock_paths(root).unwrap(),
+            vec!["pylock.toml".to_string(), "tool.py.lock".to_string()]
+        );
+    }
+}
+
+#[cfg(test)]
+mod manifest_constraints_tests {
+    use super::{rewrite_python_lock, ArtifactSource};
+
+    const URL: &str = "https://patch.socket.dev/pkg/urllib3-1.26.18-py2.py3-none-any.whl";
+    const SHA256: &str = "ccc9a9e0b18a5efc7038c504cfc580e47d2e02e5390f2e29cad833cbccb956b6";
+
+    /// `[tool.uv] constraint-dependencies` / `build-constraint-dependencies`
+    /// land in `[manifest] constraints` / `build-constraints` as
+    /// `{ name, specifier }`; uv >= 0.5.6 re-serializes a sourced package's
+    /// element as `{ name, url|path }`, so a stale specifier keeps
+    /// `uv lock --check` / `uv sync --locked` at exit 2 after a hosted scan.
+    /// Both arrays are repointed even when the project lock has no
+    /// `requirements` key (only script locks carry one), and no `overrides`
+    /// array is invented for a direct dependency.
+    #[test]
+    fn hosted_rewrite_repoints_manifest_constraints_and_build_constraints() {
+        let text = r#"version = 1
+revision = 3
+requires-python = ">=3.9"
+
+[manifest]
+constraints = [{ name = "urllib3", specifier = "==1.26.18" }]
+build-constraints = [
+    { name = "other", specifier = "==1.0" },
+    { name = "urllib3", specifier = ">=1.26" },
+]
+
+[[package]]
+name = "fixture"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "urllib3" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "urllib3", specifier = "==1.26.18" }]
+
+[[package]]
+name = "urllib3"
+version = "1.26.18"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://pypi.org/urllib3-1.26.18.tar.gz", hash = "sha256:old", size = 123 }
+wheels = [
+    { url = "https://pypi.org/urllib3-1.26.18-py2.py3-none-any.whl", hash = "sha256:old", size = 123 },
+]
+"#;
+        let rewritten = rewrite_python_lock(
+            text,
+            "urllib3",
+            "1.26.18",
+            ArtifactSource::Url(URL),
+            SHA256,
+        )
+        .unwrap()
+        .unwrap();
+        let document: toml_edit::DocumentMut = rewritten.parse().unwrap();
+        let manifest = &document["manifest"];
+        let constraint = manifest["constraints"][0].as_inline_table().unwrap();
+        assert_eq!(constraint["url"].as_str(), Some(URL));
+        assert!(constraint.get("specifier").is_none(), "{rewritten}");
+        let build = manifest["build-constraints"].as_array().unwrap();
+        let foreign = build.get(0).unwrap().as_inline_table().unwrap();
+        assert_eq!(foreign["specifier"].as_str(), Some("==1.0"));
+        assert!(foreign.get("url").is_none(), "a foreign constraint is untouched");
+        let ours = build.get(1).unwrap().as_inline_table().unwrap();
+        assert_eq!(ours["url"].as_str(), Some(URL));
+        assert!(ours.get("specifier").is_none(), "{rewritten}");
+        assert!(
+            manifest.as_table_like().unwrap().get("overrides").is_none(),
+            "a direct dependency must not gain an overrides array: {rewritten}"
+        );
+    }
+}
diff --git a/crates/socket-patch-core/src/utils/python_script.rs b/crates/socket-patch-core/src/utils/python_script.rs
index 00d4384b..52015aef 100644
--- a/crates/socket-patch-core/src/utils/python_script.rs
+++ b/crates/socket-patch-core/src/utils/python_script.rs
@@ -91,10 +91,56 @@ fn same_hosted_artifact(previous: &str, current: &str) -> bool {
         && uuid::Uuid::parse_str(current_path[grant_index + 1]).is_ok()
 }
 
-fn dotted_table() -> Item {
-    let mut table = Table::new();
-    table.set_dotted(true);
-    Item::Table(table)
+/// How a freshly created `[tool.uv.sources]` is laid out.
+///
+/// A PEP 723 script block is reverted by DOCUMENT restore
+/// (`vendor::pypi_lock::restore_document`), which can only converge on the
+/// exact pre-vendor bytes after an out-of-order multi-package revert of
+/// DIRECT dependencies (one `sources.<name>` key each) when the tables we
+/// created vanish once empty. Only DOTTED keys do that after a parse round
+/// trip (dotted-ness is syntax; `implicit` is not), so the script block
+/// keeps `tool.uv.sources.x = { … }` right after `dependencies`, where
+/// placement was never a problem. TRANSITIVE pairs are different: they share
+/// one `override-dependencies` array, and `restore_value`'s array branch
+/// flags drift as soon as the entries stop lining up, so their revert stays
+/// order-dependent whatever the layout.
+///
+/// A `pyproject.toml` is reverted by exact text replay of the recorded
+/// original, so it can use uv's own layout: header-less `[tool]` / `[tool.uv]`
+/// parents and a real `[tool.uv.sources]` table. Where that header lands is
+/// toml_edit's choice, not ours: a new table is rendered right after the
+/// last PRE-EXISTING table visited before it in depth-first key order —
+/// directly after an existing `[tool.uv]`, after `[tool.ruff]` when that is
+/// the only `[tool.*]` table (even when that puts it BEFORE `[project]`),
+/// and at the very end of the document — after a trailing `[build-system]` —
+/// when there is no `[tool]` block yet. (Dotted keys would instead render as
+/// `tool.uv.sources.x = …` in the ROOT body — i.e. ABOVE `[project]` —
+/// whenever the pyproject had no `[tool]` header yet; an older CLI wrote
+/// exactly that, and `rewrite_sources` keeps extending such a dotted table
+/// rather than adding a second, conflicting header.)
+#[derive(Clone, Copy)]
+enum SourcesLayout {
+    Dotted,
+    Tables,
+}
+
+impl SourcesLayout {
+    fn parent(self) -> Item {
+        let mut table = Table::new();
+        match self {
+            Self::Dotted => table.set_dotted(true),
+            Self::Tables => table.set_implicit(true),
+        }
+        Item::Table(table)
+    }
+
+    fn leaf(self) -> Item {
+        let mut table = Table::new();
+        if matches!(self, Self::Dotted) {
+            table.set_dotted(true);
+        }
+        Item::Table(table)
+    }
 }
 
 fn rewrite_sources(
@@ -103,21 +149,22 @@ fn rewrite_sources(
     version: &str,
     artifact: ArtifactSource<'_>,
     direct: bool,
+    layout: SourcesLayout,
 ) -> Result<(), String> {
     let (key, location) = match artifact {
         ArtifactSource::Url(location) => ("url", location),
         ArtifactSource::Path(location) => ("path", location),
     };
-    let tool = document.entry("tool").or_insert(dotted_table());
+    let tool = document.entry("tool").or_insert(layout.parent());
     let uv = tool
         .as_table_like_mut()
         .ok_or("Python tool metadata must be a table")?
         .entry("uv")
-        .or_insert(dotted_table());
+        .or_insert(layout.parent());
     let uv = uv
         .as_table_like_mut()
         .ok_or("Python tool.uv metadata must be a table")?;
-    let sources = uv.entry("sources").or_insert(dotted_table());
+    let sources = uv.entry("sources").or_insert(layout.leaf());
     let sources = sources
         .as_table_like_mut()
         .ok_or("Python tool.uv.sources must be a table")?;
@@ -198,6 +245,11 @@ pub fn rewrite_project_metadata(
         .get("project")
         .and_then(Item::as_table_like)
         .ok_or("pyproject.toml has no project table")?;
+    let tool_uv = document
+        .get("tool")
+        .and_then(Item::as_table_like)
+        .and_then(|tool| tool.get("uv"))
+        .and_then(Item::as_table_like);
     let direct = contains_dependency(project.get("dependencies"), &name)
         || project
             .get("optional-dependencies")
@@ -214,20 +266,28 @@ pub fn rewrite_project_metadata(
                 groups
                     .iter()
                     .any(|(_, group)| contains_dependency(Some(group), &name))
-            });
-    if document
-        .get("tool")
-        .and_then(Item::as_table_like)
-        .and_then(|tool| tool.get("uv"))
-        .and_then(Item::as_table_like)
-        .is_some_and(|uv| uv.contains_key("workspace"))
-    {
+            })
+        // The legacy `[tool.uv] dev-dependencies` array (still honoured by uv
+        // with a deprecation warning) is a direct declaration too: uv records
+        // it under `[package.metadata.requires-dev]`, so an override here
+        // would be redundant — and ignored by uv < 0.5.6, which does not
+        // apply `[tool.uv.sources]` to `override-dependencies`.
+        || tool_uv
+            .is_some_and(|uv| contains_dependency(uv.get("dev-dependencies"), &name));
+    if tool_uv.is_some_and(|uv| uv.contains_key("workspace")) {
         return Err(
             "hosted sources for uv workspaces require a package-scoped source mapping".to_string(),
         );
     }
-    rewrite_sources(&mut document, &name, version, artifact, direct)?;
-    let output = document.to_string();
+    rewrite_sources(
+        &mut document,
+        &name,
+        version,
+        artifact,
+        direct,
+        SourcesLayout::Tables,
+    )?;
+    let output = crate::utils::python_lock::preserve_line_endings(text, document.to_string());
     Ok((output != text).then_some(output))
 }
 
@@ -250,7 +310,14 @@ pub fn rewrite_script_metadata(
                 .filter_map(Value::as_str)
                 .any(|spec| dependency_name(spec) == name)
         });
-    rewrite_sources(&mut document, &name, version, artifact, direct)?;
+    rewrite_sources(
+        &mut document,
+        &name,
+        version,
+        artifact,
+        direct,
+        SourcesLayout::Dotted,
+    )?;
     let output = replace_script_metadata(text, &document.to_string())?;
     Ok((output != text).then_some(output))
 }
@@ -345,3 +412,388 @@ mod tests {
         );
     }
 }
+
+#[cfg(test)]
+mod rendering_tests {
+    use super::*;
+
+    const URL: &str = "https://patch.socket.dev/alpha-1.0.0-py3-none-any.whl";
+
+    /// A package declared only in the legacy `[tool.uv] dev-dependencies`
+    /// array is a DIRECT dependency for hosted wiring: uv tracks it under
+    /// `[package.metadata.requires-dev]`, so the source alone redirects it and
+    /// no `override-dependencies` entry may be added (uv < 0.5.6 ignores
+    /// sources on overrides and would reinstall the registry wheel).
+    #[test]
+    fn tool_uv_dev_dependencies_count_as_direct_for_hosted_sources() {
+        let out = rewrite_project_metadata(
+            "[project]\nname = \"p\"\ndependencies = []\n\n[tool.uv]\ndev-dependencies = [\"alpha==1.0.0\"]\n",
+            "alpha",
+            "1.0.0",
+            ArtifactSource::Url(URL),
+        )
+        .unwrap()
+        .unwrap();
+        assert!(!out.contains("override-dependencies"), "{out}");
+        assert!(
+            out.contains(&format!("[tool.uv.sources]\nalpha = {{ url = \"{URL}\" }}")),
+            "{out}"
+        );
+        assert!(
+            rewrite_project_metadata(&out, "alpha", "1.0.0", ArtifactSource::Url(URL))
+                .unwrap()
+                .is_none()
+        );
+    }
+
+    /// A second pass over a rendering must be a no-op: the source is
+    /// recognised as already present and nothing is re-emitted.
+    fn assert_settled(out: &str) {
+        assert!(
+            rewrite_project_metadata(out, "alpha", "1.0.0", ArtifactSource::Url(URL))
+                .unwrap()
+                .is_none(),
+            "second rewrite must be a no-op over:\n{out}"
+        );
+    }
+
+    /// Byte-level shape of a pyproject edit: uv's own layout — a
+    /// `[tool.uv.sources]` header AFTER `[project]` when `[project]` is the
+    /// last table, never dotted keys at the top of the file; a transitive
+    /// dep adds `[tool.uv]` with its override. (The sibling tests below pin
+    /// where the header lands when other tables follow or precede.)
+    #[test]
+    fn project_sources_render_as_uv_style_headers_after_project() {
+        let direct = rewrite_project_metadata(
+            "[project]\nname = \"p\"\nversion = \"0.1.0\"\ndependencies = [\"alpha==1.0.0\"]\n",
+            "alpha",
+            "1.0.0",
+            ArtifactSource::Url(URL),
+        )
+        .unwrap()
+        .unwrap();
+        assert_eq!(
+            direct,
+            format!("[project]\nname = \"p\"\nversion = \"0.1.0\"\ndependencies = [\"alpha==1.0.0\"]\n\n[tool.uv.sources]\nalpha = {{ url = \"{URL}\" }}\n")
+        );
+        assert_settled(&direct);
+        let transitive = rewrite_project_metadata(
+            "[project]\nname = \"p\"\ndependencies = [\"requests\"]\n",
+            "alpha",
+            "1.0.0",
+            ArtifactSource::Url(URL),
+        )
+        .unwrap()
+        .unwrap();
+        assert_eq!(
+            transitive,
+            format!("[project]\nname = \"p\"\ndependencies = [\"requests\"]\n\n[tool.uv]\noverride-dependencies = [\"alpha==1.0.0\"]\n\n[tool.uv.sources]\nalpha = {{ url = \"{URL}\" }}\n")
+        );
+        assert_settled(&transitive);
+        // An existing `[tool.uv]` header gains the sources as its own
+        // sub-table; a CRLF pyproject stays CRLF.
+        let existing = rewrite_project_metadata(
+            "[project]\r\nname = \"p\"\r\ndependencies = [\"alpha==1.0.0\"]\r\n\r\n[tool.uv]\r\ndev-dependencies = [\"pytest\"]\r\n",
+            "alpha",
+            "1.0.0",
+            ArtifactSource::Url(URL),
+        )
+        .unwrap()
+        .unwrap();
+        assert_eq!(
+            existing,
+            format!("[project]\r\nname = \"p\"\r\ndependencies = [\"alpha==1.0.0\"]\r\n\r\n[tool.uv]\r\ndev-dependencies = [\"pytest\"]\r\n\r\n[tool.uv.sources]\r\nalpha = {{ url = \"{URL}\" }}\r\n")
+        );
+        assert_settled(&existing);
+        // An existing `[tool.uv.sources]` header is reused as-is.
+        let header = rewrite_project_metadata(
+            "[project]\nname = \"p\"\ndependencies = [\"alpha==1.0.0\", \"beta\"]\n\n[tool.uv.sources]\nbeta = { git = \"https://example.test/beta\" }\n",
+            "alpha",
+            "1.0.0",
+            ArtifactSource::Url(URL),
+        )
+        .unwrap()
+        .unwrap();
+        assert_eq!(
+            header,
+            format!("[project]\nname = \"p\"\ndependencies = [\"alpha==1.0.0\", \"beta\"]\n\n[tool.uv.sources]\nbeta = {{ git = \"https://example.test/beta\" }}\nalpha = {{ url = \"{URL}\" }}\n")
+        );
+        assert_settled(&header);
+    }
+
+    /// The PEP 723 block keeps the fully dotted shape so that document
+    /// restore can drop it without a trace once every source is reverted.
+    #[test]
+    fn script_sources_stay_dotted_inside_the_metadata_block() {
+        let script = "# /// script\n# dependencies = [\"alpha==1.0.0\"]\n# ///\nprint('x')\n";
+        let out = rewrite_script_metadata(script, "alpha", "1.0.0", ArtifactSource::Url(URL))
+            .unwrap()
+            .unwrap();
+        assert_eq!(
+            out,
+            format!("# /// script\n# dependencies = [\"alpha==1.0.0\"]\n# tool.uv.sources.alpha = {{ url = \"{URL}\" }}\n# ///\nprint('x')\n")
+        );
+        assert!(
+            rewrite_script_metadata(&out, "alpha", "1.0.0", ArtifactSource::Url(URL))
+                .unwrap()
+                .is_none()
+        );
+    }
+
+    /// No `[tool]` block yet and a `[build-system]` after `[project]`:
+    /// toml_edit appends the new header after the LAST existing table, so
+    /// `[tool.uv.sources]` follows `[build-system]`, not `[project]`. CRLF
+    /// input stays CRLF.
+    #[test]
+    fn project_sources_follow_a_trailing_build_system_table() {
+        let lf = rewrite_project_metadata(
+            "[project]\nname = \"p\"\ndependencies = [\"alpha==1.0.0\"]\n\n[build-system]\nrequires = [\"hatchling\"]\nbuild-backend = \"hatchling.build\"\n",
+            "alpha",
+            "1.0.0",
+            ArtifactSource::Url(URL),
+        )
+        .unwrap()
+        .unwrap();
+        assert_eq!(
+            lf,
+            format!("[project]\nname = \"p\"\ndependencies = [\"alpha==1.0.0\"]\n\n[build-system]\nrequires = [\"hatchling\"]\nbuild-backend = \"hatchling.build\"\n\n[tool.uv.sources]\nalpha = {{ url = \"{URL}\" }}\n")
+        );
+        assert_settled(&lf);
+        let crlf = rewrite_project_metadata(
+            "[project]\r\nname = \"p\"\r\ndependencies = [\"alpha==1.0.0\"]\r\n\r\n[build-system]\r\nrequires = [\"hatchling\"]\r\nbuild-backend = \"hatchling.build\"\r\n",
+            "alpha",
+            "1.0.0",
+            ArtifactSource::Url(URL),
+        )
+        .unwrap()
+        .unwrap();
+        assert_eq!(
+            crlf,
+            format!("[project]\r\nname = \"p\"\r\ndependencies = [\"alpha==1.0.0\"]\r\n\r\n[build-system]\r\nrequires = [\"hatchling\"]\r\nbuild-backend = \"hatchling.build\"\r\n\r\n[tool.uv.sources]\r\nalpha = {{ url = \"{URL}\" }}\r\n")
+        );
+        assert_eq!(crlf.matches("\r\n").count(), crlf.matches('\n').count());
+        assert_settled(&crlf);
+    }
+
+    /// `[tool]` with `uv = { … }` as an INLINE table: there is no `[tool.uv]`
+    /// header to hang a `[tool.uv.sources]` table off, so the source has to
+    /// live inside the inline table. toml_edit renders it as a dotted
+    /// `sources.alpha = { … }` key on the `uv = { … }` line; whatever the
+    /// exact spelling, it must parse back to the source and settle on the
+    /// second pass. A transitive dep adds its override to the same table.
+    #[test]
+    fn project_sources_join_an_inline_tool_uv_table() {
+        let direct = rewrite_project_metadata(
+            "[project]\nname = \"p\"\ndependencies = [\"alpha==1.0.0\"]\n\n[tool]\nuv = { dev-dependencies = [\"pytest\"] }\n",
+            "alpha",
+            "1.0.0",
+            ArtifactSource::Url(URL),
+        )
+        .unwrap()
+        .unwrap();
+        let document: DocumentMut = direct.parse().unwrap();
+        assert_eq!(
+            document["tool"]["uv"]["sources"]["alpha"]["url"].as_str(),
+            Some(URL)
+        );
+        assert_eq!(
+            document["tool"]["uv"]["dev-dependencies"][0].as_str(),
+            Some("pytest")
+        );
+        assert!(document["tool"]["uv"].is_inline_table(), "{direct}");
+        assert_eq!(direct.matches("[tool]").count(), 1, "{direct}");
+        assert!(!direct.contains("[tool.uv"), "{direct}");
+        let uv_line = direct
+            .lines()
+            .find(|line| line.starts_with("uv = {"))
+            .unwrap_or_else(|| panic!("uv stays an inline table:\n{direct}"));
+        assert!(
+            uv_line.contains(&format!("sources.alpha = {{ url = \"{URL}\" }}")),
+            "{direct}"
+        );
+        assert!(uv_line.ends_with('}'), "{direct}");
+        assert!(direct.starts_with("[project]\nname = \"p\"\ndependencies = [\"alpha==1.0.0\"]\n\n[tool]\n"), "{direct}");
+        assert_settled(&direct);
+
+        let transitive = rewrite_project_metadata(
+            "[project]\nname = \"p\"\ndependencies = [\"requests\"]\n\n[tool]\nuv = { dev-dependencies = [\"pytest\"] }\n",
+            "alpha",
+            "1.0.0",
+            ArtifactSource::Url(URL),
+        )
+        .unwrap()
+        .unwrap();
+        let document: DocumentMut = transitive.parse().unwrap();
+        assert_eq!(
+            document["tool"]["uv"]["sources"]["alpha"]["url"].as_str(),
+            Some(URL)
+        );
+        assert_eq!(
+            document["tool"]["uv"]["override-dependencies"][0].as_str(),
+            Some("alpha==1.0.0")
+        );
+        assert!(document["tool"]["uv"].is_inline_table(), "{transitive}");
+        assert!(!transitive.contains("[tool.uv"), "{transitive}");
+        assert_settled(&transitive);
+    }
+
+    /// The header follows the tool block, not `[project]`: with `[tool.ruff]`
+    /// as the only `[tool.*]` table and `[project]` after it, the new
+    /// `[tool.uv.sources]` (and a transitive dep's `[tool.uv]`) land inside
+    /// the tool block BEFORE `[project]`. With `[tool.uv]` followed by
+    /// `[tool.ruff]`, the sources header goes right after `[tool.uv]`.
+    #[test]
+    fn project_sources_land_in_a_tool_block_that_precedes_project() {
+        let direct = rewrite_project_metadata(
+            "[tool.ruff]\nline-length = 100\n\n[project]\nname = \"p\"\ndependencies = [\"alpha==1.0.0\"]\n",
+            "alpha",
+            "1.0.0",
+            ArtifactSource::Url(URL),
+        )
+        .unwrap()
+        .unwrap();
+        assert_eq!(
+            direct,
+            format!("[tool.ruff]\nline-length = 100\n\n[tool.uv.sources]\nalpha = {{ url = \"{URL}\" }}\n\n[project]\nname = \"p\"\ndependencies = [\"alpha==1.0.0\"]\n")
+        );
+        assert_settled(&direct);
+
+        let transitive = rewrite_project_metadata(
+            "[tool.ruff]\nline-length = 100\n\n[project]\nname = \"p\"\ndependencies = [\"requests\"]\n",
+            "alpha",
+            "1.0.0",
+            ArtifactSource::Url(URL),
+        )
+        .unwrap()
+        .unwrap();
+        assert_eq!(
+            transitive,
+            format!("[tool.ruff]\nline-length = 100\n\n[tool.uv]\noverride-dependencies = [\"alpha==1.0.0\"]\n\n[tool.uv.sources]\nalpha = {{ url = \"{URL}\" }}\n\n[project]\nname = \"p\"\ndependencies = [\"requests\"]\n")
+        );
+        assert_settled(&transitive);
+
+        let after_uv = rewrite_project_metadata(
+            "[project]\nname = \"p\"\ndependencies = [\"alpha==1.0.0\"]\n\n[tool.uv]\ndev-dependencies = [\"pytest\"]\n\n[tool.ruff]\nline-length = 100\n",
+            "alpha",
+            "1.0.0",
+            ArtifactSource::Url(URL),
+        )
+        .unwrap()
+        .unwrap();
+        assert_eq!(
+            after_uv,
+            format!("[project]\nname = \"p\"\ndependencies = [\"alpha==1.0.0\"]\n\n[tool.uv]\ndev-dependencies = [\"pytest\"]\n\n[tool.uv.sources]\nalpha = {{ url = \"{URL}\" }}\n\n[tool.ruff]\nline-length = 100\n")
+        );
+        assert_settled(&after_uv);
+    }
+
+    /// Upgrade path: an older CLI wrote the source as a dotted
+    /// `tool.uv.sources.other = { … }` key in the ROOT body (above
+    /// `[project]`). The new source must extend that dotted table — one more
+    /// dotted line, no second `[tool.uv.sources]` header that would make the
+    /// document invalid — and a transitive dep's override joins it the same
+    /// way.
+    #[test]
+    fn project_sources_extend_a_dotted_root_body_table_from_an_older_cli() {
+        let direct = rewrite_project_metadata(
+            "tool.uv.sources.other = { git = \"https://example.test/other\" }\n\n[project]\nname = \"p\"\ndependencies = [\"alpha==1.0.0\", \"other\"]\n",
+            "alpha",
+            "1.0.0",
+            ArtifactSource::Url(URL),
+        )
+        .unwrap()
+        .unwrap();
+        assert_eq!(
+            direct,
+            format!("tool.uv.sources.other = {{ git = \"https://example.test/other\" }}\ntool.uv.sources.alpha = {{ url = \"{URL}\" }}\n\n[project]\nname = \"p\"\ndependencies = [\"alpha==1.0.0\", \"other\"]\n")
+        );
+        let document: DocumentMut = direct.parse().unwrap();
+        assert_eq!(
+            document["tool"]["uv"]["sources"]["other"]["git"].as_str(),
+            Some("https://example.test/other")
+        );
+        assert_eq!(
+            document["tool"]["uv"]["sources"]["alpha"]["url"].as_str(),
+            Some(URL)
+        );
+        assert_settled(&direct);
+
+        let transitive = rewrite_project_metadata(
+            "tool.uv.sources.other = { git = \"https://example.test/other\" }\n\n[project]\nname = \"p\"\ndependencies = [\"other\"]\n",
+            "alpha",
+            "1.0.0",
+            ArtifactSource::Url(URL),
+        )
+        .unwrap()
+        .unwrap();
+        assert_eq!(
+            transitive,
+            format!("tool.uv.sources.other = {{ git = \"https://example.test/other\" }}\ntool.uv.sources.alpha = {{ url = \"{URL}\" }}\ntool.uv.override-dependencies = [\"alpha==1.0.0\"]\n\n[project]\nname = \"p\"\ndependencies = [\"other\"]\n")
+        );
+        assert_settled(&transitive);
+    }
+
+    /// A user-authored `# [tool.uv.sources]` (or `# [tool.uv]`) header inside
+    /// the PEP 723 block coexists with our insertion: the source joins the
+    /// existing table, the extracted block still parses, and
+    /// `replace_script_metadata` re-comments every line so the block stays a
+    /// valid PEP 723 comment block.
+    #[test]
+    fn script_block_with_user_sources_header_stays_parseable_and_commented() {
+        fn block_lines(script: &str) -> Vec<&str> {
+            let start = script.find("# /// script\n").unwrap() + "# /// script\n".len();
+            let end = script.find("\n# ///\n").unwrap();
+            script[start..end].lines().collect()
+        }
+        let cases = [
+            (
+                "# /// script\n# dependencies = [\"alpha==1.0.0\", \"beta\"]\n#\n# [tool.uv.sources]\n# beta = { git = \"https://example.test/beta\" }\n# ///\nprint('x')\n",
+                format!("# /// script\n# dependencies = [\"alpha==1.0.0\", \"beta\"]\n#\n# [tool.uv.sources]\n# beta = {{ git = \"https://example.test/beta\" }}\n# alpha = {{ url = \"{URL}\" }}\n# ///\nprint('x')\n"),
+            ),
+            (
+                "# /// script\n# dependencies = [\"alpha==1.0.0\"]\n#\n# [tool.uv]\n# exclude-newer = \"2024-01-01T00:00:00Z\"\n# ///\nprint('x')\n",
+                format!("# /// script\n# dependencies = [\"alpha==1.0.0\"]\n#\n# [tool.uv]\n# exclude-newer = \"2024-01-01T00:00:00Z\"\n# sources.alpha = {{ url = \"{URL}\" }}\n# ///\nprint('x')\n"),
+            ),
+            (
+                "# /// script\n# dependencies = [\"requests\", \"beta\"]\n#\n# [tool.uv.sources]\n# beta = { git = \"https://example.test/beta\" }\n# ///\nprint('x')\n",
+                format!("# /// script\n# dependencies = [\"requests\", \"beta\"]\n#\n# [tool.uv]\n# override-dependencies = [\"alpha==1.0.0\"]\n#\n# [tool.uv.sources]\n# beta = {{ git = \"https://example.test/beta\" }}\n# alpha = {{ url = \"{URL}\" }}\n# ///\nprint('x')\n"),
+            ),
+        ];
+        for (script, expected) in cases {
+            let out = rewrite_script_metadata(script, "alpha", "1.0.0", ArtifactSource::Url(URL))
+                .unwrap()
+                .unwrap();
+            assert_eq!(out, expected);
+            for line in block_lines(&out) {
+                assert!(
+                    line == "#" || line.starts_with("# "),
+                    "every block line must stay a comment: {line:?} in\n{out}"
+                );
+            }
+            let (_, metadata) = script_metadata(&out).unwrap();
+            let document: DocumentMut = metadata.parse().unwrap();
+            assert_eq!(
+                document["tool"]["uv"]["sources"]["alpha"]["url"].as_str(),
+                Some(URL)
+            );
+            if script.contains("beta") {
+                assert_eq!(
+                    document["tool"]["uv"]["sources"]["beta"]["git"].as_str(),
+                    Some("https://example.test/beta")
+                );
+            }
+            if !script.contains("alpha==") {
+                assert_eq!(
+                    document["tool"]["uv"]["override-dependencies"][0].as_str(),
+                    Some("alpha==1.0.0")
+                );
+            }
+            assert!(
+                rewrite_script_metadata(&out, "alpha", "1.0.0", ArtifactSource::Url(URL))
+                    .unwrap()
+                    .is_none(),
+                "{out}"
+            );
+        }
+    }
+}
diff --git a/crates/socket-patch-core/src/vendor/lock_inventory.rs b/crates/socket-patch-core/src/vendor/lock_inventory.rs
index 73e55493..8ee9a9d0 100644
--- a/crates/socket-patch-core/src/vendor/lock_inventory.rs
+++ b/crates/socket-patch-core/src/vendor/lock_inventory.rs
@@ -1093,24 +1093,42 @@ fn parse_gem_spec_line(line: &str) -> Option<(String, String)> {
 async fn inventory_pypi_locks(project_root: &Path) -> Option<Vec<LockfileEntry>> {
     let mut out = Vec::new();
     let mut found = false;
+    let mut uv_lock = false;
     if let Ok(paths) = crate::utils::python_lock::python_lock_paths(project_root) {
         for path in paths {
-            let Ok(text) = read_regular_to_string(&project_root.join(path)).await else {
+            let Ok(text) = read_regular_to_string(&project_root.join(&path)).await else {
                 continue;
             };
             if let Some(entries) = python_lock_inventory(&text) {
                 found = true;
+                uv_lock |= path == "uv.lock";
                 out.extend(entries);
             }
         }
     }
-    if found {
-        return Some(dedup_prefer_integrity(out));
-    }
-    if let Some(out) = inventory_poetry_lock(project_root).await {
-        return Some(out);
+    // A PARSEABLE uv.lock stays the EXCLUSIVE project inventory (its
+    // precedence over poetry.lock / requirements.txt predates standalone-lock
+    // support). Exclusivity is keyed on parse SUCCESS, not on the file's
+    // presence: an unparseable uv.lock contributed nothing above, so it falls
+    // through to poetry.lock / requirements.txt exactly like a package-less
+    // poetry.lock does (`depless_poetry_lock_falls_through_to_requirements`).
+    // Keying on presence would hide every requirements pin behind a corrupt
+    // lock AND diverge from hosted, which skips an unparseable uv.lock with
+    // `redirect_uv_lock_unsupported` and still reads the other pins. A
+    // PEP 723 script lock or a PEP 751 lock is scoped to its own install,
+    // so it SUPPLEMENTS the project's tool lock: a stray `tool.py.lock`
+    // must not hide every poetry.lock / requirements.txt pin from scan's
+    // lockfile supplement and vendor's lookup.
+    if !uv_lock {
+        if let Some(entries) = inventory_poetry_lock(project_root).await {
+            found = true;
+            out.extend(entries);
+        } else if let Some(entries) = inventory_requirements_txt(project_root).await {
+            found = true;
+            out.extend(entries);
+        }
     }
-    inventory_requirements_txt(project_root).await
+    found.then(|| dedup_prefer_integrity(out))
 }
 
 fn python_archive(archive: &dyn TableLike) -> Option<(String, String)> {
@@ -1453,6 +1471,10 @@ pub async fn recover_lock_entry(
                         .to_string(),
                 );
             }
+            // The inventory canonicalizes names (PEP 503); the purl may carry
+            // the project's own spelling (`PyYAML`, `typing_extensions`) —
+            // compare in normalized form like `lookup` does.
+            let canonical_name = canonicalize_pypi_name(&name);
             for wiring in entry
                 .wiring
                 .iter()
@@ -1461,7 +1483,7 @@ pub async fn recover_lock_entry(
                 if let Some(text) = wiring.original.as_ref().and_then(Value::as_str) {
                     if let Some(entries) = python_lock_inventory(text) {
                         if let Some(resolution) = entries.into_iter().find(|candidate| {
-                            candidate.name == name
+                            candidate.name == canonical_name
                                 && candidate.version == version
                                 && candidate.resolved.is_some()
                                 && candidate.integrity != LockIntegrity::None
@@ -4400,3 +4422,171 @@ mod recover_tests {
         );
     }
 }
+
+#[cfg(test)]
+mod python_lock_union_tests {
+    use super::*;
+
+    const WHEEL_SHA: &str = "abababababababababababababababababababababababababababababababab";
+
+    fn uv_style_lock(name: &str, version: &str) -> String {
+        format!(
+            "version = 1\n\n[[package]]\nname = \"{name}\"\nversion = \"{version}\"\nsource = {{ registry = \"https://pypi.org/simple\" }}\nwheels = [{{ url = \"https://files.pythonhosted.org/{name}-{version}-py3-none-any.whl\", hash = \"sha256:{WHEEL_SHA}\" }}]\n"
+        )
+    }
+
+    fn names(entries: &[LockfileEntry]) -> Vec<(String, String)> {
+        let mut pairs: Vec<_> = entries
+            .iter()
+            .map(|entry| (entry.name.clone(), entry.version.clone()))
+            .collect();
+        pairs.sort();
+        pairs
+    }
+
+    /// A script lock is scoped to its script: it must ADD to the project's
+    /// requirements.txt / poetry.lock pins, not replace them (the base only
+    /// ever let uv.lock short-circuit the fallbacks).
+    #[tokio::test]
+    async fn script_lock_supplements_project_pins() {
+        let tmp = tempfile::tempdir().unwrap();
+        tokio::fs::write(tmp.path().join("requirements.txt"), "requests==2.31.0\n")
+            .await
+            .unwrap();
+        tokio::fs::write(
+            tmp.path().join("tool.py.lock"),
+            uv_style_lock("flask", "3.0.0"),
+        )
+        .await
+        .unwrap();
+        let entries = inventory_pypi_locks(tmp.path()).await.unwrap();
+        assert_eq!(
+            names(&entries),
+            vec![
+                ("flask".to_string(), "3.0.0".to_string()),
+                ("requests".to_string(), "2.31.0".to_string()),
+            ]
+        );
+    }
+
+    /// uv.lock keeps its exclusive precedence over the fallbacks.
+    #[tokio::test]
+    async fn uv_lock_still_hides_requirements_pins() {
+        let tmp = tempfile::tempdir().unwrap();
+        tokio::fs::write(tmp.path().join("requirements.txt"), "requests==2.31.0\n")
+            .await
+            .unwrap();
+        tokio::fs::write(tmp.path().join("uv.lock"), uv_style_lock("flask", "3.0.0"))
+            .await
+            .unwrap();
+        let entries = inventory_pypi_locks(tmp.path()).await.unwrap();
+        assert_eq!(
+            names(&entries),
+            vec![("flask".to_string(), "3.0.0".to_string())]
+        );
+    }
+
+    /// Without a uv.lock, poetry.lock is the project's tool lock: it hides
+    /// requirements.txt (the base's poetry → requirements ordering) while a
+    /// script lock still UNIONS with it — the standalone lock supplements
+    /// whichever tool lock the project has, never just uv.lock.
+    #[tokio::test]
+    async fn poetry_lock_unions_with_script_lock_and_hides_requirements() {
+        let tmp = tempfile::tempdir().unwrap();
+        tokio::fs::write(
+            tmp.path().join("poetry.lock"),
+            "[[package]]\nname = \"requests\"\nversion = \"2.31.0\"\n\n[metadata]\nlock-version = \"2.0\"\n",
+        )
+        .await
+        .unwrap();
+        tokio::fs::write(
+            tmp.path().join("tool.py.lock"),
+            uv_style_lock("flask", "3.0.0"),
+        )
+        .await
+        .unwrap();
+        tokio::fs::write(tmp.path().join("requirements.txt"), "click==8.1.7\n")
+            .await
+            .unwrap();
+        let entries = inventory_pypi_locks(tmp.path()).await.unwrap();
+        assert_eq!(
+            names(&entries),
+            vec![
+                ("flask".to_string(), "3.0.0".to_string()),
+                ("requests".to_string(), "2.31.0".to_string()),
+            ]
+        );
+    }
+
+    /// Exclusivity is keyed on a uv.lock that PARSES, not on the file's
+    /// presence: garbage TOML contributes nothing and must not hide the
+    /// requirements.txt pins behind it (hosted skips the same file with
+    /// `redirect_uv_lock_unsupported`, so the inventories agree).
+    #[tokio::test]
+    async fn unparseable_uv_lock_falls_through_to_requirements() {
+        let tmp = tempfile::tempdir().unwrap();
+        tokio::fs::write(
+            tmp.path().join("uv.lock"),
+            "version = 1\n[[package]\nname = \"flask\"\n= broken\n",
+        )
+        .await
+        .unwrap();
+        tokio::fs::write(tmp.path().join("requirements.txt"), "requests==2.31.0\n")
+            .await
+            .unwrap();
+        let entries = inventory_pypi_locks(tmp.path()).await.unwrap();
+        assert_eq!(
+            names(&entries),
+            vec![("requests".to_string(), "2.31.0".to_string())]
+        );
+    }
+
+    /// Ledger recovery must match a purl spelled the project's way
+    /// (`PyYAML`) against the PEP 503 names the inventory records.
+    #[tokio::test]
+    async fn python_document_recovery_canonicalizes_the_purl_name() {
+        let tmp = tempfile::tempdir().unwrap();
+        let lock = format!(
+            "lock-version = '1.0'\n[[packages]]\nname = 'pyyaml'\nversion = '6.0.1'\narchive = {{ url = 'https://pypi.org/PyYAML-6.0.1-py3-none-any.whl', hashes = {{ sha256 = '{WHEEL_SHA}' }} }}\n"
+        );
+        let entry = crate::vendor::state::VendorEntry {
+            ecosystem: "pypi".into(),
+            base_purl: "pkg:pypi/PyYAML@6.0.1".into(),
+            uuid: "11111111-1111-4111-8111-111111111111".into(),
+            artifact: crate::vendor::state::VendorArtifact {
+                path: ".socket/vendor/pypi/11111111-1111-4111-8111-111111111111/PyYAML-6.0.1-py3-none-any.whl".into(),
+                sha256: String::new(),
+                size: None,
+                platform_locked: None,
+                file_inventory: None,
+            },
+            wiring: vec![crate::vendor::state::WiringRecord {
+                file: "pylock.toml".into(),
+                kind: "python_lock_document".into(),
+                action: crate::vendor::state::WiringAction::Rewritten,
+                key: Some("pyyaml".into()),
+                original: Some(serde_json::Value::String(lock)),
+                new: None,
+            }],
+            lock: None,
+            took_over_go_patches: false,
+            detached: false,
+            record: None,
+            flavor: Some("python-lock".into()),
+            uv: None,
+            pnpm: None,
+            poetry: None,
+            pdm: None,
+            pipenv: None,
+        };
+        let recovered = recover_lock_entry(tmp.path(), &entry).await.unwrap();
+        assert_eq!(
+            recovered.resolved.as_deref(),
+            Some("https://pypi.org/PyYAML-6.0.1-py3-none-any.whl")
+        );
+        assert_eq!(
+            recovered.integrity,
+            LockIntegrity::Sha256Hex(WHEEL_SHA.into())
+        );
+    }
+}
diff --git a/crates/socket-patch-core/src/vendor/mod.rs b/crates/socket-patch-core/src/vendor/mod.rs
index 72fef912..9da89589 100644
--- a/crates/socket-patch-core/src/vendor/mod.rs
+++ b/crates/socket-patch-core/src/vendor/mod.rs
@@ -84,6 +84,7 @@ pub(crate) mod yarn_classic_lock;
 mod yarn_layering_tests;
 
 pub use path::{ecosystem_dir_for_purl, parse_vendor_path};
+pub use pypi_requirements::requirements_include_names;
 pub use state::{
     carry_forward_wiring, load_state, lookup_entry, save_state, VendorEntry, VendorState,
     VENDOR_STATE_REL,
diff --git a/crates/socket-patch-core/src/vendor/pypi.rs b/crates/socket-patch-core/src/vendor/pypi.rs
index ecf73eab..d6c1c8f5 100644
--- a/crates/socket-patch-core/src/vendor/pypi.rs
+++ b/crates/socket-patch-core/src/vendor/pypi.rs
@@ -763,7 +763,10 @@ pub async fn vendor_pypi(
             &record.uuid,
         )
         .await
-        .map(|(wiring, meta)| (wiring, MetaSlot::Uv(Some(meta)))),
+        .map(|(wiring, meta, advisories)| {
+            warnings.extend(advisories);
+            (wiring, MetaSlot::Uv(Some(meta)))
+        }),
         WiringPlan::PythonLocks(project) => super::pypi_lock::wire_python_locks(
             &project,
             project_root,
@@ -873,6 +876,157 @@ pub async fn revert_pypi(entry: &VendorEntry, project_root: &Path, dry_run: bool
 
 /// [`revert_pypi`] with full [`RevertOpts`]: `keep_artifact` skips the
 /// artifact deletion while the per-flavor wiring restore runs unchanged.
+/// Fail-closed twin of [`super::npm_lock::guard_unwired_textual_revert`]
+/// for the Python backends. A ledger entry with NO wiring records cannot
+/// restore any project file — that is the shape `socket-patch repair`
+/// re-synthesizes when state.json is lost (flavor stamped from the lock the
+/// reference was found in, wiring not offline-recoverable). Routing such an
+/// entry into a flavor revert that iterates zero records "succeeds", after
+/// which the caller deletes the uuid dir and drops the entry while uv.lock,
+/// the pylock, the script, or requirements.txt still resolve through the
+/// vendored wheel — every later `--frozen` / `--offline` install fails.
+/// Refuse whenever any Python project file still mentions the uuid dir, or
+/// exists but cannot be read to prove it does not — or the project cannot
+/// be enumerated to know which files to probe. With no reference left the
+/// revert is a plain orphan cleanup and proceeds.
+async fn guard_unwired_pypi_revert(
+    project_root: &Path,
+    uuid: &str,
+    uuid_dir_rel: &str,
+) -> Option<RevertOutcome> {
+    let clause = unwired_pypi_reference_clause(project_root, uuid).await?;
+    let detail = format!(
+        "refusing to remove {uuid_dir_rel}: the ledger entry records no pre-vendor wiring to \
+         replay (it was likely reconstructed by `socket-patch repair`; the pre-vendor Python \
+         lock fragments are not offline-recoverable) and {clause} — deleting the artifact \
+         would make every subsequent install fail; run `socket-patch repair` to keep the \
+         vendored artifact healthy, and revert by restoring the pre-vendor files (or by \
+         removing the dependency and re-locking) before re-running `vendor --revert`"
+    );
+    Some(RevertOutcome {
+        success: false,
+        warnings: vec![VendorWarning::new(
+            "vendor_wiring_unknown_revert_blocked",
+            detail.clone(),
+        )],
+        error: Some(detail),
+        kept_artifact: false,
+    })
+}
+
+/// The in-use probe behind [`guard_unwired_pypi_revert`]: `None` when every
+/// Python project file was read and none mentions the uuid dir; otherwise
+/// the human clause naming what blocks the revert. The probe list is the
+/// statically named project files, the root `requirements.txt` plus every
+/// `-r` include the planner may have written a pin into, and every Python
+/// lock the root directory LISTS (`uv.lock`, `pylock*.toml`, `*.py.lock`
+/// with its paired script). Every step fails closed: a root that cannot be
+/// listed, an include tree that cannot be read, or a listed lock (a symlink
+/// included — lstat only, so an unreadable target is still probed) that
+/// exists but cannot be read all block the revert, because none of them
+/// can prove the absence of a reference.
+async fn unwired_pypi_reference_clause(project_root: &Path, uuid: &str) -> Option<String> {
+    let needle = format!(".socket/vendor/pypi/{uuid}/");
+    let mut names: Vec<String> = [
+        "pyproject.toml",
+        "uv.lock",
+        "pylock.toml",
+        "poetry.lock",
+        "pdm.lock",
+        "Pipfile",
+        "Pipfile.lock",
+    ]
+    .iter()
+    .map(|name| (*name).to_string())
+    .collect();
+    match super::pypi_requirements::requirements_include_names(project_root).await {
+        Ok(includes) => names.extend(includes),
+        Err(_) => {
+            return Some(
+                "the requirements.txt include tree could not be read to prove no requirements \
+                 file references it"
+                    .to_string(),
+            )
+        }
+    }
+    // Enumerate the locks ourselves instead of through
+    // `python_lock_paths`, which follows symlinks and DROPS every entry
+    // whose target cannot be stat'ed — and whose `Err` the previous shape
+    // read as "no Python locks here". Neither may fail open here.
+    let listing = match std::fs::read_dir(project_root) {
+        Ok(listing) => listing,
+        Err(_) => {
+            return Some(
+                "the project directory could not be listed to prove no Python lock references \
+                 it"
+                .to_string(),
+            )
+        }
+    };
+    for entry in listing {
+        let Ok(entry) = entry else {
+            return Some(
+                "the project directory could not be listed to prove no Python lock references \
+                 it"
+                .to_string(),
+            );
+        };
+        let Some(name) = entry.file_name().to_str().map(str::to_string) else {
+            continue;
+        };
+        if !crate::utils::python_lock::is_python_lock_name(&name) {
+            continue;
+        }
+        // lstat only: a regular file or ANY symlink is probed (the read
+        // below fails closed on a target that cannot be opened); dirs,
+        // FIFOs and sockets under a lock name are not locks. A failed
+        // file_type() is probed too.
+        if entry
+            .file_type()
+            .is_ok_and(|ft| !ft.is_file() && !ft.is_symlink())
+        {
+            continue;
+        }
+        if let Some(script) = name.strip_suffix(".lock").filter(|s| s.ends_with(".py")) {
+            names.push(script.to_string());
+        }
+        if !names.contains(&name) {
+            names.push(name);
+        }
+    }
+    for name in &names {
+        let path = project_root.join(name);
+        if matches!(tokio::fs::try_exists(&path).await, Ok(false)) {
+            continue;
+        }
+        match read_regular_to_string(&path).await {
+            Ok(text) if text.contains(&needle) => {
+                return Some(format!("{name} still resolves through it"));
+            }
+            Ok(_) => {}
+            // Fail-closed: a file we cannot read may still reference it.
+            Err(_) => {
+                return Some(format!(
+                    "{name} exists but could not be read to prove it no longer references it"
+                ));
+            }
+        }
+    }
+    None
+}
+
+/// `VendorEntry::flavor` values the dispatch below knows how to revert —
+/// the set an UNWIRED entry must belong to (or be `None`) before it is
+/// treated as a reclaimable orphan.
+const KNOWN_PYPI_FLAVORS: [&str; 6] = [
+    "uv",
+    "python-lock",
+    "requirements",
+    "poetry",
+    "pdm",
+    "pipenv",
+];
+
 pub async fn revert_pypi_opts(
     entry: &VendorEntry,
     project_root: &Path,
@@ -882,19 +1036,64 @@ pub async fn revert_pypi_opts(
         dry_run,
         keep_artifact,
     } = opts;
-    let mut outcome = match entry.flavor.as_deref() {
-        Some("uv") => revert_uv(entry, project_root, dry_run).await,
-        Some("python-lock") => {
-            super::pypi_lock::revert_python_locks(entry, project_root, dry_run).await
+    let mut outcome = if entry.wiring.is_empty() {
+        // Nothing to replay (a `repair`-reconstructed entry): no project
+        // file can be restored, so the only work left is the artifact
+        // deletion below. Under `keep_artifact` (`--preserve-state`) even
+        // that is skipped — the revert is a no-op and the in-use guard,
+        // which exists only to protect the deletion, has nothing to
+        // protect (npm's precedent). Otherwise the artifact may only go
+        // when no Python project file provably resolves through it. Once
+        // the guard clears, the entry is a plain orphan: the flavor
+        // dispatch is skipped on purpose — flavor `uv` with uv.lock gone
+        // fails "cannot read uv.lock", and flavor `None` (what `repair`
+        // stamps for requirements/poetry/pdm/pipenv reconstructions) is
+        // unknown to the dispatch — and either would leave the orphan
+        // unreclaimable forever.
+        if keep_artifact {
+            return RevertOutcome::ok();
         }
-        Some("requirements") => revert_requirements(entry, project_root, dry_run).await,
-        Some("poetry") => super::pypi_poetry::revert_poetry(entry, project_root, dry_run).await,
-        Some("pdm") => super::pypi_pdm::revert_pdm(entry, project_root, dry_run).await,
-        Some("pipenv") => super::pypi_pipenv::revert_pipenv(entry, project_root, dry_run).await,
-        other => {
+        // An UNKNOWN flavor (a newer binary's backend) still fails closed
+        // even here: its project files may reference the artifact from a
+        // place this guard does not know to probe. `None` is `repair`'s
+        // own stamp and every known flavor's files are probed.
+        if let Some(flavor) = entry
+            .flavor
+            .as_deref()
+            .filter(|f| !KNOWN_PYPI_FLAVORS.contains(f))
+        {
             return RevertOutcome::failed(format!(
-                "unknown pypi vendor flavor {other:?}; cannot revert"
-            ))
+                "unknown pypi vendor flavor {:?}; cannot revert",
+                Some(flavor)
+            ));
+        }
+        let uuid_dir_rel = vendor_uuid_dir_rel("pypi", &entry.uuid)
+            .unwrap_or_else(|| format!(".socket/vendor/pypi/{:?}", entry.uuid));
+        if let Some(blocked) =
+            guard_unwired_pypi_revert(project_root, &entry.uuid, &uuid_dir_rel).await
+        {
+            return blocked;
+        }
+        RevertOutcome::ok()
+    } else {
+        match entry.flavor.as_deref() {
+            Some("uv") => revert_uv(entry, project_root, dry_run).await,
+            Some("python-lock") => {
+                super::pypi_lock::revert_python_locks(entry, project_root, dry_run).await
+            }
+            Some("requirements") => revert_requirements(entry, project_root, dry_run).await,
+            Some("poetry") => {
+                super::pypi_poetry::revert_poetry(entry, project_root, dry_run).await
+            }
+            Some("pdm") => super::pypi_pdm::revert_pdm(entry, project_root, dry_run).await,
+            Some("pipenv") => {
+                super::pypi_pipenv::revert_pipenv(entry, project_root, dry_run).await
+            }
+            other => {
+                return RevertOutcome::failed(format!(
+                    "unknown pypi vendor flavor {other:?}; cannot revert"
+                ))
+            }
         }
     };
     if !outcome.success || dry_run {
@@ -2816,6 +3015,495 @@ wheels = [
         }
     }
 
+    /// A ledger entry with NO wiring (the shape `socket-patch repair`
+    /// re-synthesizes when state.json is lost) cannot restore any file.
+    /// Routing it into a flavor revert that iterates zero records used to
+    /// "succeed", after which the caller deleted the uuid dir and dropped
+    /// the entry while the lock still resolved through the vendored wheel.
+    /// Both Python-lock backends must refuse while anything references it.
+    #[tokio::test]
+    async fn unwired_python_entry_revert_refuses_while_lock_references_artifact() {
+        let rel_wheel = format!(".socket/vendor/pypi/{UUID}/six-1.16.0-py2.py3-none-any.whl");
+        let cases: Vec<(&str, Vec<(&str, String)>)> = vec![
+            (
+                "uv",
+                vec![
+                    (
+                        "pyproject.toml",
+                        format!("[project]\nname = \"p\"\ndependencies = [\"six==1.16.0\"]\n\n[tool.uv.sources]\nsix = {{ path = \"{rel_wheel}\" }}\n"),
+                    ),
+                    (
+                        "uv.lock",
+                        format!("version = 1\n\n[[package]]\nname = \"six\"\nversion = \"1.16.0\"\nsource = {{ path = \"{rel_wheel}\" }}\n"),
+                    ),
+                ],
+            ),
+            (
+                "python-lock",
+                vec![(
+                    "pylock.toml",
+                    format!("lock-version = \"1.0\"\n\n[[packages]]\nname = \"six\"\nversion = \"1.16.0\"\narchive = {{ path = \"{rel_wheel}\" }}\n"),
+                )],
+            ),
+            (
+                "python-lock",
+                vec![
+                    ("tool.py.lock", "version = 1\n".to_string()),
+                    (
+                        "tool.py",
+                        format!("# /// script\n# dependencies = [\"six==1.16.0\"]\n# [tool.uv.sources]\n# six = {{ path = \"{rel_wheel}\" }}\n# ///\n"),
+                    ),
+                ],
+            ),
+        ];
+        for (flavor, files) in cases {
+            let tmp = tempfile::tempdir().unwrap();
+            let root = tmp.path();
+            for (name, text) in &files {
+                tokio::fs::write(root.join(name), text).await.unwrap();
+            }
+            let wheel = root.join(&rel_wheel);
+            tokio::fs::create_dir_all(wheel.parent().unwrap())
+                .await
+                .unwrap();
+            tokio::fs::write(&wheel, b"wheel bytes").await.unwrap();
+            let entry = revert_entry(flavor, &rel_wheel, Vec::new());
+            for dry_run in [true, false] {
+                let outcome = revert_pypi(&entry, root, dry_run).await;
+                assert!(
+                    !outcome.success,
+                    "{flavor} dry_run={dry_run}: unwired revert must refuse: {outcome:?}"
+                );
+                assert_eq!(
+                    outcome.warnings.len(),
+                    1,
+                    "{flavor}: {:?}",
+                    outcome.warnings
+                );
+                assert_eq!(
+                    outcome.warnings[0].code,
+                    "vendor_wiring_unknown_revert_blocked"
+                );
+                assert!(!outcome.kept_artifact);
+            }
+            assert!(
+                wheel.is_file(),
+                "{flavor}: the referenced artifact must survive"
+            );
+            for (name, text) in &files {
+                assert_eq!(
+                    &tokio::fs::read_to_string(root.join(name)).await.unwrap(),
+                    text,
+                    "{flavor}: {name} must be untouched"
+                );
+            }
+        }
+    }
+
+    /// Nothing references the artifact any more (the user re-locked by
+    /// hand): an unwired entry's revert is a plain orphan cleanup and may
+    /// proceed — the guard is about live references, not about wiring.
+    #[tokio::test]
+    async fn unwired_python_entry_revert_proceeds_when_nothing_references_artifact() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        tokio::fs::write(
+            root.join("pyproject.toml"),
+            "[project]\nname = \"p\"\ndependencies = [\"six==1.16.0\"]\n",
+        )
+        .await
+        .unwrap();
+        tokio::fs::write(
+            root.join("uv.lock"),
+            "version = 1\n\n[[package]]\nname = \"six\"\nversion = \"1.16.0\"\nsource = { registry = \"https://pypi.org/simple\" }\n",
+        )
+        .await
+        .unwrap();
+        let rel_wheel = format!(".socket/vendor/pypi/{UUID}/six-1.16.0-py2.py3-none-any.whl");
+        let wheel = root.join(&rel_wheel);
+        tokio::fs::create_dir_all(wheel.parent().unwrap())
+            .await
+            .unwrap();
+        tokio::fs::write(&wheel, b"wheel bytes").await.unwrap();
+        let entry = revert_entry("uv", &rel_wheel, Vec::new());
+        let outcome = revert_pypi(&entry, root, false).await;
+        assert!(outcome.success, "{:?}", outcome.error);
+        assert!(!wheel.exists(), "the orphaned artifact dir is removed");
+    }
+
+    /// An unwired entry with a wheel still referenced by the project files.
+    /// Returns the wheel path (so the caller can assert survival/removal).
+    async fn unwired_uv_fixture(root: &Path, rel_wheel: &str) -> PathBuf {
+        tokio::fs::write(
+            root.join("pyproject.toml"),
+            format!("[project]\nname = \"p\"\ndependencies = [\"six==1.16.0\"]\n\n[tool.uv.sources]\nsix = {{ path = \"{rel_wheel}\" }}\n"),
+        )
+        .await
+        .unwrap();
+        tokio::fs::write(
+            root.join("uv.lock"),
+            format!("version = 1\n\n[[package]]\nname = \"six\"\nversion = \"1.16.0\"\nsource = {{ path = \"{rel_wheel}\" }}\n"),
+        )
+        .await
+        .unwrap();
+        let wheel = root.join(rel_wheel);
+        tokio::fs::create_dir_all(wheel.parent().unwrap())
+            .await
+            .unwrap();
+        tokio::fs::write(&wheel, b"wheel bytes").await.unwrap();
+        wheel
+    }
+
+    /// `rollback/remove --preserve-state` (`keep_artifact`) never deletes the
+    /// artifact, and an unwired entry has nothing to restore — so there is
+    /// nothing for the in-use guard to protect. It used to refuse with
+    /// `vendor_wiring_unknown_revert_blocked` although the revert would
+    /// have touched nothing (npm skips the guard under `keep_artifact` for
+    /// exactly this reason: the refusal exists only to protect the deletion).
+    #[tokio::test]
+    async fn unwired_entry_preserve_state_skips_guard() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        let rel_wheel = format!(".socket/vendor/pypi/{UUID}/six-1.16.0-py2.py3-none-any.whl");
+        let wheel = unwired_uv_fixture(root, &rel_wheel).await;
+        let entry = revert_entry("uv", &rel_wheel, Vec::new());
+        for dry_run in [true, false] {
+            let outcome = revert_pypi_opts(
+                &entry,
+                root,
+                RevertOpts {
+                    dry_run,
+                    keep_artifact: true,
+                },
+            )
+            .await;
+            assert!(
+                outcome.success,
+                "dry_run={dry_run}: preserve-state revert of an unwired entry must succeed: \
+                 {outcome:?}"
+            );
+            assert!(
+                outcome.warnings.is_empty(),
+                "dry_run={dry_run}: no refusal warning: {:?}",
+                outcome.warnings
+            );
+            assert!(!outcome.kept_artifact, "keep_artifact is not a drift-keep");
+            assert!(wheel.is_file(), "dry_run={dry_run}: the wheel is kept");
+        }
+    }
+
+    /// Restores a directory mode on drop so a failing assertion never leaves
+    /// an unlistable/unreadable tempdir behind for `TempDir` to choke on.
+    #[cfg(unix)]
+    struct ModeGuard(PathBuf);
+    #[cfg(unix)]
+    impl Drop for ModeGuard {
+        fn drop(&mut self) {
+            use std::os::unix::fs::PermissionsExt as _;
+            let _ = std::fs::set_permissions(&self.0, std::fs::Permissions::from_mode(0o755));
+        }
+    }
+
+    /// The guard used to treat a `read_dir` failure on the project root as
+    /// "no Python locks here" (and its static list lacked uv.lock and
+    /// pylock.toml), so on an execute-only root nothing was probed and the
+    /// referenced wheel was deleted while uv.lock / pylock.toml still
+    /// resolved through it. An unlistable root cannot prove the absence of
+    /// a reference: refuse, fail-closed.
+    #[cfg(unix)]
+    #[tokio::test]
+    async fn unwired_python_entry_revert_refuses_when_root_unlistable() {
+        use std::os::unix::fs::PermissionsExt as _;
+        if unsafe { libc::geteuid() } == 0 {
+            eprintln!("skipping: running as root, directory perms are not enforced");
+            return;
+        }
+        let rel_wheel = format!(".socket/vendor/pypi/{UUID}/six-1.16.0-py2.py3-none-any.whl");
+        // Only the LOCK references the wheel (pyproject.toml was already
+        // hand-restored): the reference is reachable through the listing
+        // alone, not through a statically named project file.
+        let cases: Vec<(&str, Vec<(&str, String)>)> = vec![
+            (
+                "uv",
+                vec![
+                    (
+                        "pyproject.toml",
+                        "[project]\nname = \"p\"\ndependencies = [\"six==1.16.0\"]\n".to_string(),
+                    ),
+                    (
+                        "uv.lock",
+                        format!("version = 1\n\n[[package]]\nname = \"six\"\nversion = \"1.16.0\"\nsource = {{ path = \"{rel_wheel}\" }}\n"),
+                    ),
+                ],
+            ),
+            (
+                "python-lock",
+                vec![(
+                    "pylock.toml",
+                    format!("lock-version = \"1.0\"\n\n[[packages]]\nname = \"six\"\nversion = \"1.16.0\"\narchive = {{ path = \"{rel_wheel}\" }}\n"),
+                )],
+            ),
+        ];
+        for (flavor, files) in cases {
+            let tmp = tempfile::tempdir().unwrap();
+            let root = tmp.path();
+            for (name, text) in &files {
+                tokio::fs::write(root.join(name), text).await.unwrap();
+            }
+            let wheel = root.join(&rel_wheel);
+            tokio::fs::create_dir_all(wheel.parent().unwrap())
+                .await
+                .unwrap();
+            tokio::fs::write(&wheel, b"wheel bytes").await.unwrap();
+            let entry = revert_entry(flavor, &rel_wheel, Vec::new());
+            // Execute-only: paths under the root still resolve (the wheel
+            // and every known lock name), only the listing is denied.
+            std::fs::set_permissions(root, std::fs::Permissions::from_mode(0o311)).unwrap();
+            let _restore = ModeGuard(root.to_path_buf());
+            assert!(
+                std::fs::read_dir(root).is_err(),
+                "0o311 must make the root unlistable on this host"
+            );
+            let outcome = revert_pypi(&entry, root, false).await;
+            assert!(
+                !outcome.success,
+                "{flavor}: revert under an unlistable root must refuse: {outcome:?}"
+            );
+            assert_eq!(outcome.warnings.len(), 1, "{flavor}: {:?}", outcome.warnings);
+            assert_eq!(
+                outcome.warnings[0].code,
+                "vendor_wiring_unknown_revert_blocked"
+            );
+            assert!(
+                outcome.warnings[0].detail.contains("could not be listed"),
+                "{flavor}: {}",
+                outcome.warnings[0].detail
+            );
+            assert!(!outcome.kept_artifact);
+            assert!(
+                wheel.is_file(),
+                "{flavor}: the referenced artifact must survive"
+            );
+        }
+    }
+
+    /// A lock that is a SYMLINK whose target cannot be stat'ed used to be
+    /// dropped from the probe list (the lister follows the link and drops
+    /// any entry whose metadata fails), so the guard never saw it and the
+    /// wheel it may reference was deleted. Listing must keep symlinks on
+    /// lstat alone; the unreadable target then hits the fail-closed read.
+    /// Both a static-list name and a listing-only name are covered.
+    #[cfg(unix)]
+    #[tokio::test]
+    async fn unwired_python_entry_revert_refuses_when_lock_target_unstatable() {
+        use std::os::unix::fs::PermissionsExt as _;
+        if unsafe { libc::geteuid() } == 0 {
+            eprintln!("skipping: running as root, directory perms are not enforced");
+            return;
+        }
+        let rel_wheel = format!(".socket/vendor/pypi/{UUID}/six-1.16.0-py2.py3-none-any.whl");
+        for lock_name in ["pylock.toml", "pylock.dev.toml"] {
+            let tmp = tempfile::tempdir().unwrap();
+            let root = tmp.path();
+            let locked = root.join("locked");
+            tokio::fs::create_dir(&locked).await.unwrap();
+            tokio::fs::write(
+                locked.join(lock_name),
+                format!("lock-version = \"1.0\"\n\n[[packages]]\nname = \"six\"\nversion = \"1.16.0\"\narchive = {{ path = \"{rel_wheel}\" }}\n"),
+            )
+            .await
+            .unwrap();
+            tokio::fs::symlink(format!("locked/{lock_name}"), root.join(lock_name))
+                .await
+                .unwrap();
+            let wheel = root.join(&rel_wheel);
+            tokio::fs::create_dir_all(wheel.parent().unwrap())
+                .await
+                .unwrap();
+            tokio::fs::write(&wheel, b"wheel bytes").await.unwrap();
+            let entry = revert_entry("python-lock", &rel_wheel, Vec::new());
+            std::fs::set_permissions(&locked, std::fs::Permissions::from_mode(0o000)).unwrap();
+            let _restore = ModeGuard(locked.clone());
+            assert!(
+                std::fs::metadata(root.join(lock_name)).is_err(),
+                "{lock_name}: the link target must be unstatable on this host"
+            );
+            let outcome = revert_pypi(&entry, root, false).await;
+            assert!(
+                !outcome.success,
+                "{lock_name}: revert with an unreadable lock target must refuse: {outcome:?}"
+            );
+            assert_eq!(
+                outcome.warnings.len(),
+                1,
+                "{lock_name}: {:?}",
+                outcome.warnings
+            );
+            assert_eq!(
+                outcome.warnings[0].code,
+                "vendor_wiring_unknown_revert_blocked"
+            );
+            assert!(
+                outcome
+                    .warnings[0]
+                    .detail
+                    .contains(&format!("{lock_name} exists but could not be read")),
+                "{lock_name}: {}",
+                outcome.warnings[0].detail
+            );
+            assert!(
+                wheel.is_file(),
+                "{lock_name}: the referenced artifact must survive"
+            );
+        }
+    }
+
+    /// Once the guard finds no reference, an unwired entry is a plain
+    /// orphan and must be reclaimable. Dispatching it by flavor used to
+    /// fail forever: flavor `uv` with uv.lock gone → "cannot read uv.lock".
+    #[tokio::test]
+    async fn unwired_uv_entry_without_uv_lock_reclaims_orphan() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        tokio::fs::write(
+            root.join("pyproject.toml"),
+            "[project]\nname = \"p\"\ndependencies = [\"six==1.16.0\"]\n",
+        )
+        .await
+        .unwrap();
+        let rel_wheel = format!(".socket/vendor/pypi/{UUID}/six-1.16.0-py2.py3-none-any.whl");
+        let wheel = root.join(&rel_wheel);
+        tokio::fs::create_dir_all(wheel.parent().unwrap())
+            .await
+            .unwrap();
+        tokio::fs::write(&wheel, b"wheel bytes").await.unwrap();
+        let entry = revert_entry("uv", &rel_wheel, Vec::new());
+        let dry = revert_pypi(&entry, root, true).await;
+        assert!(dry.success, "dry run previews the orphan cleanup: {dry:?}");
+        assert!(wheel.is_file(), "dry run deletes nothing");
+        let outcome = revert_pypi(&entry, root, false).await;
+        assert!(outcome.success, "{:?}", outcome.error);
+        assert!(!outcome.kept_artifact);
+        assert!(
+            !root.join(format!(".socket/vendor/pypi/{UUID}")).exists(),
+            "the orphaned artifact dir is removed"
+        );
+    }
+
+    /// Same reclaim contract for flavor `None` — the shape `repair` stamps
+    /// for requirements/poetry/pdm/pipenv reconstructions, which the
+    /// dispatch used to reject with "unknown pypi vendor flavor None".
+    #[tokio::test]
+    async fn unwired_entry_flavor_none_reclaims_orphan() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        tokio::fs::write(root.join("requirements.txt"), "six==1.16.0\n")
+            .await
+            .unwrap();
+        let rel_wheel = format!(".socket/vendor/pypi/{UUID}/six-1.16.0-py2.py3-none-any.whl");
+        let wheel = root.join(&rel_wheel);
+        tokio::fs::create_dir_all(wheel.parent().unwrap())
+            .await
+            .unwrap();
+        tokio::fs::write(&wheel, b"wheel bytes").await.unwrap();
+        let mut entry = revert_entry("uv", &rel_wheel, Vec::new());
+        entry.flavor = None;
+        let outcome = revert_pypi(&entry, root, false).await;
+        assert!(outcome.success, "{:?}", outcome.error);
+        assert!(!outcome.kept_artifact);
+        assert!(
+            !root.join(format!(".socket/vendor/pypi/{UUID}")).exists(),
+            "the orphaned artifact dir is removed"
+        );
+        // An UNKNOWN flavor fails closed whether wired or not: a newer
+        // backend's project files may reference the artifact from a place
+        // this guard does not probe.
+        let mut unknown = revert_entry("uv", &rel_wheel, Vec::new());
+        unknown.flavor = Some("frobnicate".into());
+        let outcome = revert_pypi(&unknown, root, false).await;
+        assert!(!outcome.success, "{outcome:?}");
+        assert!(
+            outcome
+                .error
+                .as_deref()
+                .is_some_and(|e| e.contains("unknown pypi vendor flavor")),
+            "{outcome:?}"
+        );
+        let mut wired = revert_entry("uv", &rel_wheel, Vec::new());
+        wired.flavor = Some("frobnicate".into());
+        wired.wiring.push(WiringRecord {
+            file: "requirements.txt".into(),
+            kind: "requirements_line".into(),
+            action: WiringAction::Added,
+            key: None,
+            original: None,
+            new: None,
+        });
+        let outcome = revert_pypi(&wired, root, false).await;
+        assert!(!outcome.success, "{outcome:?}");
+        assert!(
+            outcome
+                .error
+                .as_deref()
+                .is_some_and(|e| e.contains("unknown pypi vendor flavor")),
+            "{outcome:?}"
+        );
+    }
+
+    /// The requirements planner writes vendored pins into `-r` includes, so
+    /// a reference may live ONLY in an include. The guard used to probe the
+    /// root requirements.txt alone and let the include-referenced wheel go.
+    #[tokio::test]
+    async fn unwired_requirements_entry_refuses_on_include_reference() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        let rel_wheel = format!(".socket/vendor/pypi/{UUID}/six-1.16.0-py2.py3-none-any.whl");
+        tokio::fs::write(root.join("requirements.txt"), "-r requirements/base.txt\n")
+            .await
+            .unwrap();
+        tokio::fs::create_dir(root.join("requirements")).await.unwrap();
+        let include = format!(
+            "./{rel_wheel} --hash=sha256:{}  # socket-patch vendor: six==1.16.0\n",
+            "0".repeat(64)
+        );
+        tokio::fs::write(root.join("requirements/base.txt"), &include)
+            .await
+            .unwrap();
+        let wheel = root.join(&rel_wheel);
+        tokio::fs::create_dir_all(wheel.parent().unwrap())
+            .await
+            .unwrap();
+        tokio::fs::write(&wheel, b"wheel bytes").await.unwrap();
+        let entry = revert_entry("requirements", &rel_wheel, Vec::new());
+        for dry_run in [true, false] {
+            let outcome = revert_pypi(&entry, root, dry_run).await;
+            assert!(
+                !outcome.success,
+                "dry_run={dry_run}: include-referenced revert must refuse: {outcome:?}"
+            );
+            assert_eq!(outcome.warnings.len(), 1, "{:?}", outcome.warnings);
+            assert_eq!(
+                outcome.warnings[0].code,
+                "vendor_wiring_unknown_revert_blocked"
+            );
+            assert!(
+                outcome.warnings[0]
+                    .detail
+                    .contains("requirements/base.txt still resolves through it"),
+                "{}",
+                outcome.warnings[0].detail
+            );
+        }
+        assert!(wheel.is_file(), "the include-referenced wheel must survive");
+        assert_eq!(
+            tokio::fs::read_to_string(root.join("requirements/base.txt"))
+                .await
+                .unwrap(),
+            include,
+            "the include is untouched"
+        );
+    }
+
     const PIPENV_REGISTRY_LOCK: &str = r#"{
     "_meta": {
         "hash": {"sha256": "x"},
diff --git a/crates/socket-patch-core/src/vendor/pypi_lock.rs b/crates/socket-patch-core/src/vendor/pypi_lock.rs
index 2bde43c8..9c38ad7b 100644
--- a/crates/socket-patch-core/src/vendor/pypi_lock.rs
+++ b/crates/socket-patch-core/src/vendor/pypi_lock.rs
@@ -1,11 +1,10 @@
 use std::collections::BTreeSet;
 use std::path::Path;
 
-use tokio::io::AsyncReadExt as _;
 use toml_edit::{DocumentMut, Item, Table, TableLike, Value};
 
 use crate::crawlers::python_crawler::canonicalize_pypi_name;
-use crate::utils::fs::{atomic_write_bytes_preserving_mode, open_regular_file};
+use crate::utils::fs::{atomic_write_bytes_preserving_mode, is_symlink, read_regular_to_string};
 use crate::utils::python_lock::{
     is_python_lock_name, python_lock_paths, rewrite_python_lock, ArtifactSource,
 };
@@ -33,27 +32,48 @@ pub(super) struct PythonLocks {
     pub pin: Option<(String, String)>,
 }
 
+/// FIFO-safe read that FOLLOWS a symlink to a regular file. Discovery
+/// (`python_lock_paths`) follows links too, so a shared `pylock.dev.toml`
+/// link beside a regular `pylock.toml` reads like the file it points at —
+/// an lstat-based "is this a regular file" pre-check here rejected the
+/// link, and because `contains_target`/`load_python_locks` bubble the FIRST
+/// unreadable sibling, one stray link blocked vendoring of the whole
+/// project. Whether a linked file may be WRITTEN is a separate question,
+/// answered by [`refuse_symlinked`] right before the writers run.
 async fn read_file(path: &Path) -> Result<String, Failure> {
-    let metadata = tokio::fs::symlink_metadata(path).await.map_err(|error| {
+    read_regular_to_string(path).await.map_err(|error| {
         (
             "pypi_lock_read_failed",
-            format!("cannot read {}: {error}", path.display()),
+            if error.kind() == std::io::ErrorKind::InvalidInput {
+                error.to_string()
+            } else {
+                format!("cannot read {}: {error}", path.display())
+            },
         )
-    })?;
-    if !metadata.is_file() {
-        return Err((
-            "pypi_lock_read_failed",
-            format!("{} is not a regular file", path.display()),
-        ));
+    })
+}
+
+/// Every writer here stages a replacement next to `file` and renames over
+/// it, which REPLACES a symlink with a regular file: the link target goes
+/// stale (uv itself writes through the link), and a later revert restores
+/// bytes but never the link (git shows a 120000→100644 typechange). Refuse
+/// before the first write instead — same fail-closed policy as the hosted
+/// replay flush guard.
+fn symlink_refusal(file: &str) -> String {
+    format!(
+        "{file} is a symbolic link; socket-patch rewrites files in place with an atomic \
+         rename, which would replace the link — replace the link with a regular file (or \
+         run socket-patch in the directory it points to) and re-run"
+    )
+}
+
+async fn refuse_symlinked(root: &Path, files: impl Iterator<Item = &String>) -> Option<String> {
+    for file in files {
+        if is_symlink(&root.join(file)).await {
+            return Some(symlink_refusal(file));
+        }
     }
-    let (mut file, _) = open_regular_file(path)
-        .await
-        .map_err(|error| ("pypi_lock_read_failed", error.to_string()))?;
-    let mut text = String::new();
-    file.read_to_string(&mut text)
-        .await
-        .map_err(|error| ("pypi_lock_read_failed", error.to_string()))?;
-    Ok(text)
+    None
 }
 
 fn package<'a>(document: &'a DocumentMut, name: &str, version: &str) -> Option<&'a Table> {
@@ -290,13 +310,19 @@ pub(super) async fn wire_python_locks(
                         }
                     }
                 }
-                rewritten = document.to_string();
+                rewritten = crate::utils::python_lock::preserve_line_endings(
+                    &file.text,
+                    document.to_string(),
+                );
             }
         }
         if rewritten != file.text {
             edits.push((file.name.clone(), file.text.clone(), rewritten, KIND));
         }
     }
+    if let Some(detail) = refuse_symlinked(root, edits.iter().map(|(file, ..)| file)).await {
+        return Err(("pypi_lock_symlink_unsupported", detail));
+    }
     for (file, original, _, _) in &edits {
         if read_file(&root.join(file)).await? != *original {
             return Err((
@@ -498,7 +524,7 @@ fn restore_document(live: &str, original: &str, new: &str) -> Result<(String, bo
         if drifted {
             current_text
         } else {
-            live.to_string()
+            crate::utils::python_lock::preserve_line_endings(&current_text, live.to_string())
         },
         drifted,
     ))
@@ -575,6 +601,12 @@ pub(super) async fn revert_python_locks(
         }
     }
     if !dry_run && warnings.is_empty() {
+        // A refused write fails the revert outright: the artifact and the
+        // ledger entry stay so the restore can be retried once the link is
+        // a regular file again.
+        if let Some(detail) = refuse_symlinked(root, edits.iter().map(|(file, ..)| file)).await {
+            return RevertOutcome::failed(detail);
+        }
         for (file, original, _) in &edits {
             match read_file(&root.join(file)).await {
                 Ok(live) if live == *original => {}
@@ -818,4 +850,418 @@ mod tests {
         assert!(allowed_file("job.py", SCRIPT_KIND));
         assert!(!allowed_file("../job.py", SCRIPT_KIND));
     }
+
+    /// The two-package PEP 751 document with every newline CRLF.
+    fn crlf(text: &str) -> String {
+        text.replace('\n', "\r\n")
+    }
+
+    const UUID: &str = "11111111-1111-4111-8111-111111111111";
+
+    /// `pylock.toml` locking `one` and `two` upstream, plus the second copy a
+    /// sibling symlink points at.
+    async fn write_pylock(root: &Path, name: &str, text: &str) {
+        tokio::fs::write(root.join(name), text).await.unwrap();
+    }
+
+    /// A stray `pylock.dev.toml` SYMLINK (pointing at a lock that does not
+    /// contain the target) beside a REGULAR `pylock.toml` that does. On main
+    /// the symlink was invisible (`python_lock_paths` skipped links); since
+    /// discovery started following links, `read_file`'s
+    /// `symlink_metadata().is_file()` pre-check rejected it with
+    /// `pypi_lock_read_failed`, and because `contains_target` /
+    /// `load_python_locks` bubble the FIRST unreadable sibling, the stray link
+    /// blocked vendoring of the whole project. A link to a regular file must
+    /// read like the file (`open_regular_file`'s fstat already accepts it).
+    #[cfg(unix)]
+    #[tokio::test]
+    async fn stray_sibling_symlink_does_not_block_regular_pylock() {
+        let temp = tempfile::tempdir().unwrap();
+        let root = temp.path();
+        write_pylock(root, "pylock.toml", LOCK).await;
+        let other = "lock-version = \"1.0\"\n\n[[packages]]\nname = \"other\"\nversion = \"9\"\nwheels = [{url = \"https://example.test/other.whl\", hashes = {sha256 = \"other\"}}]\n";
+        std::fs::create_dir_all(root.join("shared")).unwrap();
+        write_pylock(root, "shared/pylock.dev.toml", other).await;
+        std::os::unix::fs::symlink("shared/pylock.dev.toml", root.join("pylock.dev.toml"))
+            .unwrap();
+
+        let paths = python_lock_paths(root).unwrap();
+        assert_eq!(
+            paths,
+            vec!["pylock.dev.toml".to_string(), "pylock.toml".to_string()],
+            "discovery must still FOLLOW the link (a shared pylock is a real project file)"
+        );
+        assert_eq!(
+            contains_target(root, &paths, "one", "1").await,
+            Ok(true),
+            "a readable non-referencing sibling link must not fail the routing probe"
+        );
+        assert_eq!(
+            contains_target(root, &paths, "other", "9").await,
+            Ok(true),
+            "the link itself reads like the file it points at"
+        );
+        let project = load_python_locks(root, "one", "1", UUID).await.unwrap();
+        assert!(!project.in_sync);
+        let records = wire_python_locks(
+            &project,
+            root,
+            "one",
+            "1",
+            ".socket/vendor/pypi/11111111-1111-4111-8111-111111111111/one-1-py3-none-any.whl",
+            &"a".repeat(64),
+        )
+        .await
+        .unwrap();
+        assert_eq!(
+            records.iter().map(|r| r.file.as_str()).collect::<Vec<_>>(),
+            vec!["pylock.toml"],
+            "only the regular lock that contains the target is wired"
+        );
+        assert!(
+            std::fs::read_to_string(root.join("pylock.toml"))
+                .unwrap()
+                .contains("one-1-py3-none-any.whl")
+        );
+        assert!(
+            std::fs::symlink_metadata(root.join("pylock.dev.toml"))
+                .unwrap()
+                .file_type()
+                .is_symlink(),
+            "the stray link is left alone"
+        );
+        assert_eq!(
+            std::fs::read_to_string(root.join("shared/pylock.dev.toml")).unwrap(),
+            other
+        );
+    }
+
+    /// A DANGLING sibling link is not a lock: discovery's `fs::metadata`
+    /// follow fails, so the name is skipped and the regular lock beside it
+    /// routes/wires as if the link were absent.
+    #[cfg(unix)]
+    #[tokio::test]
+    async fn dangling_sibling_symlink_is_ignored() {
+        let temp = tempfile::tempdir().unwrap();
+        let root = temp.path();
+        write_pylock(root, "pylock.toml", LOCK).await;
+        std::os::unix::fs::symlink("missing/pylock.dev.toml", root.join("pylock.dev.toml"))
+            .unwrap();
+
+        let paths = python_lock_paths(root).unwrap();
+        assert_eq!(paths, vec!["pylock.toml".to_string()]);
+        assert_eq!(contains_target(root, &paths, "one", "1").await, Ok(true));
+        let project = load_python_locks(root, "one", "1", UUID).await.unwrap();
+        assert_eq!(project.files.len(), 1);
+        // Reading the dangling name directly still fails as unreadable — the
+        // filter lives in discovery, not in a swallowed read error.
+        assert!(matches!(
+            read_file(&root.join("pylock.dev.toml")).await,
+            Err(("pypi_lock_read_failed", _))
+        ));
+    }
+
+    fn symlink_refusal_names(result: &Result<Vec<WiringRecord>, Failure>, file: &str) {
+        match result {
+            Err((code, detail)) => {
+                assert_eq!(*code, "pypi_lock_symlink_unsupported", "{detail}");
+                assert!(
+                    detail.starts_with(&format!("{file} is a symbolic link")),
+                    "the refusal must name the linked file: {detail}"
+                );
+                assert!(detail.contains("atomic rename"), "{detail}");
+                assert!(detail.contains("re-run"), "{detail}");
+            }
+            Ok(records) => panic!("must refuse before writing, wired {records:?}"),
+        }
+    }
+
+    /// The lock the wiring is about to rewrite is a symlink. Every writer
+    /// here stages next to the path and renames over it, which REPLACES the
+    /// link with a regular file (the target goes stale, rollback restores
+    /// bytes but never the link — git shows a 120000→100644 typechange). The
+    /// hosted replay side already refuses such a flush; the vendored write
+    /// side must refuse BEFORE touching anything, with a stable code naming
+    /// the file.
+    #[cfg(unix)]
+    #[tokio::test]
+    async fn symlinked_target_lock_refused_before_write() {
+        let temp = tempfile::tempdir().unwrap();
+        let root = temp.path();
+        std::fs::create_dir_all(root.join("shared")).unwrap();
+        write_pylock(root, "shared/pylock.toml", LOCK).await;
+        std::os::unix::fs::symlink("shared/pylock.toml", root.join("pylock.toml")).unwrap();
+
+        let project = load_python_locks(root, "one", "1", UUID).await.unwrap();
+        let result = wire_python_locks(
+            &project,
+            root,
+            "one",
+            "1",
+            ".socket/vendor/pypi/11111111-1111-4111-8111-111111111111/one-1-py3-none-any.whl",
+            &"a".repeat(64),
+        )
+        .await;
+        symlink_refusal_names(&result, "pylock.toml");
+        assert!(
+            std::fs::symlink_metadata(root.join("pylock.toml"))
+                .unwrap()
+                .file_type()
+                .is_symlink(),
+            "the link must survive: a rename-over would have turned it into a regular file"
+        );
+        assert_eq!(
+            std::fs::read_to_string(root.join("shared/pylock.toml")).unwrap(),
+            LOCK,
+            "the link target must stay byte-identical"
+        );
+        assert!(!root.join(".socket").exists());
+    }
+
+    /// The paired PEP 723 script is the symlink (its `.py.lock` is regular):
+    /// the script's `[tool.uv.sources]` rewrite goes through the same
+    /// rename-over writer, so the refusal must cover it too and name the
+    /// SCRIPT, not the lock.
+    #[cfg(unix)]
+    #[tokio::test]
+    async fn symlinked_paired_script_refused_before_write() {
+        let temp = tempfile::tempdir().unwrap();
+        let root = temp.path();
+        let lock = "version = 1\n[[package]]\nname = \"one\"\nversion = \"1\"\nsource = {registry = \"https://pypi.org/simple\"}\n";
+        let script = "# /// script\n# dependencies = [\"one==1\"]\n# ///\nprint('hi')\n";
+        write_pylock(root, "example.py.lock", lock).await;
+        std::fs::create_dir_all(root.join("shared")).unwrap();
+        tokio::fs::write(root.join("shared/example.py"), script)
+            .await
+            .unwrap();
+        std::os::unix::fs::symlink("shared/example.py", root.join("example.py")).unwrap();
+
+        let project = load_python_locks(root, "one", "1", UUID).await.unwrap();
+        let result = wire_python_locks(
+            &project,
+            root,
+            "one",
+            "1",
+            "one-1-py3-none-any.whl",
+            &"a".repeat(64),
+        )
+        .await;
+        symlink_refusal_names(&result, "example.py");
+        assert!(
+            std::fs::symlink_metadata(root.join("example.py"))
+                .unwrap()
+                .file_type()
+                .is_symlink()
+        );
+        assert_eq!(
+            std::fs::read_to_string(root.join("shared/example.py")).unwrap(),
+            script
+        );
+        assert_eq!(
+            std::fs::read_to_string(root.join("example.py.lock")).unwrap(),
+            lock,
+            "the regular lock must not be written when its paired script is refused"
+        );
+    }
+
+    /// Revert twin: the lock was wired as a regular file, then the checkout
+    /// restored the committed SYMLINK (git typechange back) pointing at a copy
+    /// carrying the vendored bytes. `read_file` follows the link fine, so the
+    /// restore plan is computable — but writing it would replace the link.
+    /// The revert must FAIL (artifact + ledger entry kept, nothing written).
+    #[cfg(unix)]
+    #[tokio::test]
+    async fn revert_refuses_symlinked_lock_and_keeps_artifact() {
+        let temp = tempfile::tempdir().unwrap();
+        let root = temp.path();
+        write_pylock(root, "pylock.toml", LOCK).await;
+        let project = load_python_locks(root, "one", "1", UUID).await.unwrap();
+        let wheel = ".socket/vendor/pypi/11111111-1111-4111-8111-111111111111/one-1-py3-none-any.whl";
+        let records = wire_python_locks(&project, root, "one", "1", wheel, &"a".repeat(64))
+            .await
+            .unwrap();
+        let vendored = std::fs::read_to_string(root.join("pylock.toml")).unwrap();
+        assert_ne!(vendored, LOCK);
+        let entry: VendorEntry = serde_json::from_value(serde_json::json!({
+            "ecosystem": "pypi",
+            "basePurl": "pkg:pypi/one@1",
+            "uuid": UUID,
+            "artifact": { "path": wheel, "sha256": "a".repeat(64) },
+            "wiring": serde_json::to_value(&records).unwrap(),
+            "flavor": "python-lock",
+        }))
+        .unwrap();
+
+        std::fs::create_dir_all(root.join("shared")).unwrap();
+        std::fs::rename(root.join("pylock.toml"), root.join("shared/pylock.toml")).unwrap();
+        std::os::unix::fs::symlink("shared/pylock.toml", root.join("pylock.toml")).unwrap();
+
+        let outcome = revert_python_locks(&entry, root, false).await;
+        assert!(!outcome.success, "{outcome:?}");
+        let error = outcome.error.expect("a failed revert carries its reason");
+        assert!(
+            error.starts_with("pylock.toml is a symbolic link"),
+            "the failure must name the linked file: {error}"
+        );
+        assert!(error.contains("atomic rename"), "{error}");
+        assert!(
+            std::fs::symlink_metadata(root.join("pylock.toml"))
+                .unwrap()
+                .file_type()
+                .is_symlink(),
+            "the link must survive the refused revert"
+        );
+        assert_eq!(
+            std::fs::read_to_string(root.join("shared/pylock.toml")).unwrap(),
+            vendored,
+            "the target keeps the vendored bytes: nothing was restored through the link"
+        );
+        // Dry runs plan only — they never reach the writer, so the link is no
+        // obstacle and the plan reports a clean restore.
+        let dry = revert_python_locks(&entry, root, true).await;
+        assert!(dry.success && dry.warnings.is_empty(), "{dry:?}");
+    }
+
+    /// `restore_document`'s post-restore `preserve_line_endings`: the ledger
+    /// recorded LF `original`/`new`, but the live file is the vendored text
+    /// checked out under autocrlf (every newline CRLF). `live != new`
+    /// byte-wise, so this takes the structural path (not the `live == new`
+    /// short-circuit) and must converge on the ORIGINAL in the live file's
+    /// CRLF convention with no drift.
+    #[test]
+    fn restore_document_converges_lf_ledger_crlf_live() {
+        let new = rewrite_python_lock(
+            LOCK,
+            "one",
+            "1",
+            ArtifactSource::Path(".socket/vendor/one-1-py3-none-any.whl"),
+            "first",
+        )
+        .unwrap()
+        .unwrap();
+        let live = crlf(&new);
+        assert_ne!(live, new, "the CRLF live text must not short-circuit");
+        let (restored, drifted) = restore_document(&live, LOCK, &new).unwrap();
+        assert!(!drifted, "a pure line-ending difference is not drift");
+        assert_eq!(restored, crlf(LOCK));
+    }
+
+    /// The mirror: CRLF-recorded `original`/`new` (vendored on Windows), live
+    /// file normalized to LF by a later checkout. Converges on the original
+    /// content in LF.
+    #[test]
+    fn restore_document_converges_crlf_ledger_lf_live() {
+        let original = crlf(LOCK);
+        let new = rewrite_python_lock(
+            &original,
+            "one",
+            "1",
+            ArtifactSource::Path(".socket/vendor/one-1-py3-none-any.whl"),
+            "first",
+        )
+        .unwrap()
+        .unwrap();
+        assert!(new.contains("\r\n"), "the rewriter keeps the CRLF convention");
+        let live = new.replace("\r\n", "\n");
+        let (restored, drifted) = restore_document(&live, &original, &new).unwrap();
+        assert!(!drifted);
+        assert_eq!(restored, LOCK);
+    }
+
+    /// Two packages vendored in sequence under CRLF and reverted OUT of
+    /// order (`one` first, while `two`'s edit is still live). The
+    /// single-package pure-CRLF revert short-circuits at `live == new`, so
+    /// only this shape exercises the structural restore + line-ending
+    /// re-application on a CRLF document — both steps must converge without
+    /// drift and the final text must be the CRLF original.
+    #[test]
+    fn crlf_two_package_reverts_converge_out_of_order() {
+        let original = crlf(LOCK);
+        let first = rewrite_python_lock(
+            &original,
+            "one",
+            "1",
+            ArtifactSource::Path(".socket/vendor/one-1-py3-none-any.whl"),
+            "first",
+        )
+        .unwrap()
+        .unwrap();
+        let both = rewrite_python_lock(
+            &first,
+            "two",
+            "2",
+            ArtifactSource::Path(".socket/vendor/two-2-py3-none-any.whl"),
+            "second",
+        )
+        .unwrap()
+        .unwrap();
+        assert!(both.contains("\r\n") && !both.replace("\r\n", "").contains('\n'));
+        let (second_only, drifted) = restore_document(&both, &original, &first).unwrap();
+        assert!(!drifted);
+        assert!(second_only.contains("https://example.test/one.whl"));
+        assert!(second_only.contains(".socket/vendor/two-2-py3-none-any.whl"));
+        assert!(
+            !second_only.replace("\r\n", "").contains('\n'),
+            "the intermediate document keeps CRLF throughout: {second_only:?}"
+        );
+        let (restored, drifted) = restore_document(&second_only, &first, &both).unwrap();
+        assert!(!drifted);
+        assert_eq!(restored, original);
+    }
+
+    /// KNOWN LIMITATION (documented, not fixed here): two TRANSITIVE deps
+    /// vendored into one PEP 723 script share the `[tool.uv]
+    /// override-dependencies` ARRAY. Reverting the OLDER one first (`one`,
+    /// while `two`'s override is still live) cannot be expressed by
+    /// `restore_value`: the array grew from absent → 1 → 2 entries, the live
+    /// 2-entry array matches neither recorded shape, and an array is not
+    /// table-like, so the key is flagged as drift and the script is left
+    /// untouched (`vendor_lock_entry_drifted`, entry kept). Reverting `two`
+    /// first (`live == new`) then `one` converges; so does a SECOND pass over
+    /// `one` after `two` is gone. Direct deps (`[tool.uv.sources]` table
+    /// entries) revert in any order — see
+    /// `script_sources_revert_out_of_order_without_empty_tables`.
+    #[test]
+    fn script_transitive_pair_revert_out_of_order() {
+        let metadata = "dependencies = [\"top==1\"]\n";
+        let script =
+            replace_script_metadata("# /// script\n# ///\nprint('unchanged')\n", metadata).unwrap();
+        let first = rewrite_script_metadata(
+            &script,
+            "one",
+            "1",
+            ArtifactSource::Path(".socket/vendor/one.whl"),
+        )
+        .unwrap()
+        .unwrap();
+        let both = rewrite_script_metadata(
+            &first,
+            "two",
+            "2",
+            ArtifactSource::Path(".socket/vendor/two.whl"),
+        )
+        .unwrap()
+        .unwrap();
+        let (_, first_metadata) = script_metadata(&first).unwrap();
+        let (_, both_metadata) = script_metadata(&both).unwrap();
+        assert!(both_metadata.contains("override-dependencies"));
+
+        // Older first: flagged as drift, text preserved verbatim.
+        let (kept, drifted) = restore_document(&both_metadata, metadata, &first_metadata).unwrap();
+        assert!(
+            drifted,
+            "current behavior: the shared override array reads as drift"
+        );
+        assert_eq!(kept, both_metadata, "drift keeps the live text untouched");
+
+        // Newer first converges (short-circuit), then the older one does too.
+        let (second_reverted, drifted) =
+            restore_document(&both_metadata, &first_metadata, &both_metadata).unwrap();
+        assert!(!drifted);
+        assert_eq!(second_reverted, first_metadata);
+        let (restored, drifted) =
+            restore_document(&second_reverted, metadata, &first_metadata).unwrap();
+        assert!(!drifted);
+        assert_eq!(restored, metadata);
+    }
 }
diff --git a/crates/socket-patch-core/src/vendor/pypi_requirements.rs b/crates/socket-patch-core/src/vendor/pypi_requirements.rs
index 6af1a1ca..6b7c7dde 100644
--- a/crates/socket-patch-core/src/vendor/pypi_requirements.rs
+++ b/crates/socket-patch-core/src/vendor/pypi_requirements.rs
@@ -603,6 +603,82 @@ fn vendor_line(
 /// must never edit them. The root file is always element 0.
 async fn collect_requirements_files(root: &Path) -> Result<Vec<ReqFile>, (&'static str, String)> {
     let mut out: Vec<ReqFile> = Vec::new();
+    walk_requirements_tree(root, |rel, path, read| match read {
+        Ok(content) => {
+            // Out-of-root (`../`) and absolute includes resolve outside any
+            // committable root — readable so a pin inside can refuse, never
+            // editable. (`Path::join` passes an absolute `rel` through
+            // verbatim.)
+            let editable = is_in_root_rel(rel);
+            out.push(ReqFile {
+                rel: rel.to_string(),
+                content,
+                editable,
+            });
+            Ok(true)
+        }
+        Err(_) if out.is_empty() => Err((
+            "pypi_no_requirements",
+            format!("cannot read {}", path.display()),
+        )),
+        // A broken include is pip's error to report; vendor just can't see
+        // inside it. Skip.
+        Err(_) => Ok(false),
+    })
+    .await?;
+    // Depth-first stack order put the root last among pushes; restore "root
+    // first" deterministically.
+    out.sort_by_key(|f| f.rel != "requirements.txt");
+    Ok(out)
+}
+
+/// Every requirements file the vendor planner may have written a pin into:
+/// the root `requirements.txt` plus each IN-ROOT `-r`/`--requirement`
+/// include it reaches (same walk as the planner, so a vendored pin hosted in
+/// an include is found where the planner put it). Names are root-relative
+/// (`requirements/base.txt`), the root first; a file that does not exist is
+/// still named (so a caller probing it sees a clean "absent"), it is just
+/// not descended into. FIFO-safe. `Err` when a reached file EXISTS but
+/// cannot be read (a permission-denied include, a FIFO in its place): the
+/// tree is then unknowable, and callers that must prove the absence of a
+/// reference — the unwired-revert guard — fail closed on it. Out-of-root
+/// and absolute includes are never editable, so they are neither named nor
+/// followed.
+pub async fn requirements_include_names(root: &Path) -> std::io::Result<Vec<String>> {
+    let mut names: Vec<String> = Vec::new();
+    walk_requirements_tree(root, |rel, _path, read| {
+        if !is_in_root_rel(rel) {
+            return Ok(false);
+        }
+        names.push(rel.to_string());
+        match read {
+            Ok(_) => Ok(true),
+            Err(e) if e.kind() == std::io::ErrorKind::NotFound => Ok(false),
+            Err(e) => Err(e),
+        }
+    })
+    .await?;
+    names.sort_by_key(|rel| rel != "requirements.txt");
+    Ok(names)
+}
+
+/// A root-relative requirements path that stays inside the project root
+/// (not `../…`, not absolute) — the only files the planner may edit.
+fn is_in_root_rel(rel: &str) -> bool {
+    !rel.starts_with("../") && !Path::new(rel).is_absolute()
+}
+
+/// The shared include walk behind [`collect_requirements_files`] and
+/// [`requirements_include_names`]: depth-first from the root
+/// `requirements.txt`, each `-r`/`--requirement` target resolved against the
+/// INCLUDING file's directory and lexically normalized, visited-set cycle
+/// guard, FIFO-safe reads. `visit` sees every reached file with its read
+/// result and answers whether to descend into its includes (`Ok(true)`), or
+/// aborts the walk with its own error.
+async fn walk_requirements_tree<E>(
+    root: &Path,
+    mut visit: impl FnMut(&str, &Path, std::io::Result<String>) -> Result<bool, E>,
+) -> Result<(), E> {
     let mut visited: HashSet<String> = HashSet::new();
     let mut stack: Vec<(String, PathBuf)> = vec![(
         "requirements.txt".to_string(),
@@ -612,47 +688,37 @@ async fn collect_requirements_files(root: &Path) -> Result<Vec<ReqFile>, (&'stat
         if !visited.insert(rel.clone()) {
             continue;
         }
-        let Ok(content) = read_regular_to_string(&path).await else {
-            if out.is_empty() {
-                return Err((
-                    "pypi_no_requirements",
-                    format!("cannot read {}", path.display()),
-                ));
+        let read = read_regular_to_string(&path).await;
+        // Parse the includes BEFORE handing the content over (the visitor
+        // takes it by value); nothing is pushed unless it asks to descend.
+        let includes: Vec<String> = match &read {
+            Ok(content) => {
+                let include_dir = match rel.rfind('/') {
+                    Some(i) => rel[..i].to_string(),
+                    None => String::new(),
+                };
+                logical_lines(content)
+                    .iter()
+                    .filter_map(|ll| include_target(&ll.text))
+                    .map(|target| {
+                        let joined = if include_dir.is_empty() {
+                            target.to_string()
+                        } else {
+                            format!("{include_dir}/{target}")
+                        };
+                        normalize_rel_path(&joined)
+                    })
+                    .collect()
             }
-            // A broken include is pip's error to report; vendor just can't
-            // see inside it. Skip.
-            continue;
+            Err(_) => Vec::new(),
         };
-        // Out-of-root (`../`) and absolute includes resolve outside any
-        // committable root — readable so a pin inside can refuse, never
-        // editable. (`Path::join` passes an absolute `rel` through verbatim.)
-        let editable = !rel.starts_with("../") && !Path::new(&rel).is_absolute();
-        let include_dir = match rel.rfind('/') {
-            Some(i) => rel[..i].to_string(),
-            None => String::new(),
-        };
-        for ll in logical_lines(&content) {
-            let Some(target) = include_target(&ll.text) else {
-                continue;
-            };
-            let joined = if include_dir.is_empty() {
-                target.to_string()
-            } else {
-                format!("{include_dir}/{target}")
-            };
-            let normalized = normalize_rel_path(&joined);
-            stack.push((normalized.clone(), root.join(&normalized)));
+        if visit(&rel, &path, read)? {
+            for normalized in includes {
+                stack.push((normalized.clone(), root.join(&normalized)));
+            }
         }
-        out.push(ReqFile {
-            rel,
-            content,
-            editable,
-        });
     }
-    // Depth-first stack order put the root last among pushes; restore "root
-    // first" deterministically.
-    out.sort_by_key(|f| f.rel != "requirements.txt");
-    Ok(out)
+    Ok(())
 }
 
 /// The `-r`/`--requirement` include target of a logical line, if any.
@@ -832,6 +898,73 @@ mod tests {
     use super::*;
     use crate::vendor::state::VendorArtifact;
 
+    /// [`requirements_include_names`] names every file the planner may
+    /// have pinned into — root first, nested includes resolved against the
+    /// including file, a missing include still named but not descended —
+    /// and never an out-of-root include (never editable). A reached
+    /// include that exists but cannot be read (a FIFO here) is an `Err`,
+    /// so a fail-closed caller can refuse.
+    #[tokio::test]
+    async fn requirements_include_names_walks_in_root_includes() {
+        let tmp = tempfile::tempdir().unwrap();
+        let root = tmp.path();
+        tokio::fs::create_dir(root.join("requirements")).await.unwrap();
+        tokio::fs::write(
+            root.join("requirements.txt"),
+            "-r requirements/base.txt\n-c constraints.txt\n-r ../shared.txt\n",
+        )
+        .await
+        .unwrap();
+        tokio::fs::write(root.join("constraints.txt"), "six<2\n")
+            .await
+            .unwrap();
+        tokio::fs::write(
+            root.join("requirements/base.txt"),
+            "--requirement=dev.txt\n-r missing.txt\nsix==1.16.0\n",
+        )
+        .await
+        .unwrap();
+        tokio::fs::write(root.join("requirements/dev.txt"), "pytest\n")
+            .await
+            .unwrap();
+        let names = requirements_include_names(root).await.unwrap();
+        assert_eq!(names[0], "requirements.txt", "{names:?}");
+        let mut rest = names[1..].to_vec();
+        rest.sort();
+        assert_eq!(
+            rest,
+            vec![
+                "requirements/base.txt".to_string(),
+                "requirements/dev.txt".to_string(),
+                "requirements/missing.txt".to_string(),
+            ],
+            "constraints and out-of-root includes are never named"
+        );
+
+        // No root requirements.txt at all: still names the root (absent).
+        let empty = tempfile::tempdir().unwrap();
+        assert_eq!(
+            requirements_include_names(empty.path()).await.unwrap(),
+            vec!["requirements.txt".to_string()]
+        );
+
+        #[cfg(unix)]
+        {
+            tokio::fs::remove_file(root.join("requirements/dev.txt"))
+                .await
+                .unwrap();
+            let fifo = std::ffi::CString::new(
+                root.join("requirements/dev.txt").to_str().unwrap(),
+            )
+            .unwrap();
+            assert_eq!(unsafe { libc::mkfifo(fifo.as_ptr(), 0o644) }, 0);
+            let err = requirements_include_names(root)
+                .await
+                .expect_err("an include that exists but cannot be read is an Err");
+            assert_ne!(err.kind(), std::io::ErrorKind::NotFound, "{err:?}");
+        }
+    }
+
     const UUID: &str = "9f6b2c4e-1d3a-4f6b-8c2d-7e5a9b1c3d5f";
     const REL_WHEEL: &str =
         ".socket/vendor/pypi/9f6b2c4e-1d3a-4f6b-8c2d-7e5a9b1c3d5f/six-1.16.0-py2.py3-none-any.whl";
diff --git a/crates/socket-patch-core/src/vendor/pypi_uv.rs b/crates/socket-patch-core/src/vendor/pypi_uv.rs
index 9cd66557..2afd4657 100644
--- a/crates/socket-patch-core/src/vendor/pypi_uv.rs
+++ b/crates/socket-patch-core/src/vendor/pypi_uv.rs
@@ -6,7 +6,10 @@
 //! to the registry by a plain `uv sync`. So vendor always writes BOTH — the
 //! pyproject sources entry (plus, for transitive deps, a
 //! `[tool.uv] override-dependencies` pin, which sources DO apply to — claim
-//! 8) and the lock's `[[package]]` / `requires-dist` / `[manifest]` fragments.
+//! 8 — but only on uv >= 0.5.6: 0.2.35–0.5.3 ignore sources for overrides
+//! and a plain `uv sync` there reinstalls the registry wheel, hence the
+//! `pypi_uv_override_requires_uv_0_5_6` advisory on that branch) and the
+//! lock's `[[package]]` / `requires-dist` / `[manifest]` fragments.
 //!
 //! All lock edits are targeted text surgery rather than a TOML re-serialize:
 //! the spike proved a surgical edit reproduces uv's own serializer output
@@ -19,7 +22,14 @@ use std::path::Path;
 use toml_edit::{DocumentMut, Item, Table, Value};
 
 use crate::crawlers::python_crawler::canonicalize_pypi_name;
-use crate::utils::fs::atomic_write_bytes_preserving_mode;
+// `read_regular_to_string` is the FIFO-safe guarded reader (`O_NONBLOCK`
+// open + fstat regular-file check): a FIFO planted as `pyproject.toml` or
+// `uv.lock` fails fast instead of wedging every uv-project vendor run (and
+// revert) forever in an `open(2)` that waits for a writer — the
+// flavor-routing probes ahead of the load are metadata-only, so these are
+// the first opens.
+use crate::utils::fs::{atomic_write_bytes_preserving_mode, read_regular_to_string};
+use crate::utils::python_lock::preserve_line_endings;
 
 use super::common::{item_get, pep508_name, pep621_declared_names, record};
 use super::state::{UvMeta, VendorEntry, WiringAction, WiringRecord};
@@ -39,21 +49,6 @@ const HIGHEST_TESTED_LOCK_REVISION: u64 = 3;
 /// header block (real ones are a few KiB).
 const MAX_WHEEL_METADATA_BYTES: u64 = 4 * 1024 * 1024;
 
-/// Guarded read shared in shape with the sibling backend twins:
-/// `open_regular_file` opens with `O_NONBLOCK` and rejects non-regular
-/// files, so a FIFO planted as `pyproject.toml` or `uv.lock` fails fast
-/// instead of wedging every uv-project vendor run (and revert) forever in
-/// an `open(2)` that waits for a writer — the flavor-routing probes ahead
-/// of the load are metadata-only, so these are the first opens.
-async fn read_regular_to_string(path: &Path) -> std::io::Result<String> {
-    use tokio::io::AsyncReadExt as _;
-
-    let (mut file, metadata) = crate::utils::fs::open_regular_file(path).await?;
-    let mut content = String::with_capacity(metadata.len() as usize);
-    file.read_to_string(&mut content).await?;
-    Ok(content)
-}
-
 /// How the target package is declared, which picks the wiring strategy.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 enum UvDepClass {
@@ -111,10 +106,15 @@ pub(super) async fn load_uv_project(root: &Path) -> Result<UvProject, (&'static
         )
     })?;
 
+    // Real-binary behavior behind the wording: <= 0.2.6 cannot parse a
+    // relative path source at all; 0.2.17–0.2.34 install one under --frozen
+    // / plain sync, but `--locked` rejects any non-canonical spelling, plain
+    // sync (0.2.34) and every `uv lock` absolutize it, resolution is
+    // CWD-relative, and 0.2.17/0.2.18 never verify the wheel hash.
     if lock.contains_key("distribution") {
         return Err((
             "pypi_uv_legacy_lock_unsupported",
-            "uv 0.1 lockfiles require absolute file URLs; upgrade to uv >=0.2 for portable native vendoring, or use a requirements.txt installation".to_string(),
+            "uv `[[distribution]]` lockfiles (uv < 0.2.35, experimental `uv lock`) cannot carry a portable local wheel: `--locked` rejects relative paths and `uv lock`/`uv sync` rewrite them to absolute ones; upgrade to uv >=0.2.35 for native vendoring, or use a requirements.txt installation".to_string(),
         ));
     }
 
@@ -237,9 +237,14 @@ pub(super) async fn load_uv_project(root: &Path) -> Result<UvProject, (&'static
 }
 
 /// Direct iff the package is named (PEP 508 name, canonicalized) anywhere in
-/// `project.dependencies`, `project.optional-dependencies`, or the PEP 735
-/// `dependency-groups` — every surface `[tool.uv.sources]` applies to without
-/// an override.
+/// `project.dependencies`, `project.optional-dependencies`, the PEP 735
+/// `dependency-groups`, or the legacy `[tool.uv] dev-dependencies` array —
+/// every surface `[tool.uv.sources]` applies to without an override. uv
+/// (through 0.12.15, with a deprecation warning) still honours the legacy
+/// array and records it exactly like `dependency-groups.dev`: in the root
+/// unit's `[package.metadata.requires-dev]`. Classifying it Transitive
+/// would take the override branch and leave that entry's `specifier` in
+/// place — `uv lock --check` / `uv sync --locked` red on every uv >= 0.2.37.
 fn classify_dependency(p: &UvProject, canon_name: &str) -> UvDepClass {
     let mut declared: Vec<String> = Vec::new();
     pep621_declared_names(&p.pyproject, &mut declared);
@@ -260,6 +265,19 @@ fn classify_dependency(p: &UvProject, canon_name: &str) -> UvDepClass {
             }
         }
     }
+    if let Some(dev) = p
+        .pyproject
+        .get("tool")
+        .and_then(|t| item_get(t, "uv"))
+        .and_then(|u| item_get(u, "dev-dependencies"))
+        .and_then(Item::as_array)
+    {
+        declared.extend(
+            dev.iter()
+                .filter_map(Value::as_str)
+                .map(|s| pep508_name(s).to_string()),
+        );
+    }
     if declared
         .iter()
         .any(|n| canonicalize_pypi_name(n) == canon_name)
@@ -426,7 +444,8 @@ pub(super) fn wired_pin(
 /// Wire the pair for the vendored wheel. Writes `pyproject.toml` FIRST, then
 /// `uv.lock`; a failed lock write unwinds the pyproject from the recorded
 /// original so the pair is never left half-wired (either half alone is a
-/// silent no-op or a silent revert — spike claims 7/9).
+/// silent no-op or a silent revert — spike claims 7/9). The third element
+/// carries wiring-time advisories (non-fatal, surfaced with the outcome).
 #[allow(clippy::too_many_arguments)]
 pub(super) async fn wire_uv(
     p: &UvProject,
@@ -437,7 +456,9 @@ pub(super) async fn wire_uv(
     wheel_file_name: &str,
     wheel_sha256_hex: &str,
     record_uuid: &str,
-) -> Result<(Vec<WiringRecord>, UvMeta), (&'static str, String)> {
+) -> Result<(Vec<WiringRecord>, UvMeta, Vec<VendorWarning>), (&'static str, String)> {
+    // Before ANY write: a symlinked half would be replaced by the rename.
+    refuse_symlinked_pair(root).await?;
     match check_target_guards(p, canon_name, record_uuid)? {
         // Defensive: the orchestrator short-circuits in-sync pre-flight and
         // never calls wire on it (we must never re-record our own edit as an
@@ -456,6 +477,7 @@ pub(super) async fn wire_uv(
     }
     let class = classify_dependency(p, canon_name);
     let mut wiring: Vec<WiringRecord> = Vec::new();
+    let mut advisories: Vec<VendorWarning> = Vec::new();
 
     // ── pyproject.toml (computed in memory; committed before the lock) ────
     let mut doc = p.pyproject.clone();
@@ -467,6 +489,19 @@ pub(super) async fn wire_uv(
         .is_none();
 
     if class == UvDepClass::Transitive {
+        // uv 0.2.35–0.5.3 do NOT apply [tool.uv.sources] to
+        // override-dependencies: a plain `uv sync` on those releases silently
+        // reinstalls the registry wheel (the lock still names the vendored
+        // path, so `--frozen` installs it). No lock-shape marker separates
+        // 0.5.3 from 0.5.6, so this cannot be an offline refusal — advise.
+        advisories.push(VendorWarning::new(
+            "pypi_uv_override_requires_uv_0_5_6",
+            format!(
+                "transitive wiring of {canon_name} via [tool.uv] override-dependencies is \
+                 honored only by uv >= 0.5.6; older uv reinstalls the registry wheel on a \
+                 plain `uv sync` — pin uv or make the package a direct dependency"
+            ),
+        ));
         let spec = format!("{canon_name}=={version}");
         let uv_table = ensure_table(&mut doc, &["tool", "uv"])?;
         if !had_uv_table {
@@ -521,6 +556,10 @@ pub(super) async fn wire_uv(
                     .and_then(Item::as_value)
                     .map(|v| v.to_string().trim().to_string())
                     .unwrap_or_default();
+                // Multi-line arrays render LF; record both fragments in the
+                // file's own convention or revert's exact-text splice misses.
+                let old_text = preserve_line_endings(&p.pyproject_text, old_text);
+                let new_text = preserve_line_endings(&p.pyproject_text, new_text);
                 wiring.push(record(
                     "pyproject.toml",
                     "uv_override",
@@ -555,7 +594,9 @@ pub(super) async fn wire_uv(
         None,
         format!("{canon_name} = {{ path = \"{rel_wheel}\" }}"),
     ));
-    let new_pyproject = doc.to_string();
+    // toml_edit re-emits every newline as LF; a CRLF pyproject would come
+    // back all-LF (whole-file churn, and revert splices never restore it).
+    let new_pyproject = preserve_line_endings(&p.pyproject_text, doc.to_string());
 
     // ── uv.lock text surgery (fully computed before any write) ────────────
     let mut new_lock = p.lock_text.clone();
@@ -617,6 +658,43 @@ pub(super) async fn wire_uv(
         }
     }
 
+    // [manifest] constraints / build-constraints naming the target (either
+    // class). Recorded LAST so the reverse-order revert restores these
+    // whole-line fragments before the requires-dist element they may be
+    // byte-identical to is searched for.
+    let constraint_edits = rewrite_manifest_constraints(&new_lock, canon_name, rel_wheel)?;
+    if !constraint_edits.is_empty() {
+        // uv 0.2.37–0.5.3 serialize `[manifest] constraints` as
+        // `{ name, specifier }` regardless of sources, so the repointed entry
+        // makes `uv sync --locked` fail there (a plain `uv sync` rewrites the
+        // entry back and still installs the patch; `--frozen` is unaffected);
+        // uv >= 0.5.6 REQUIRES the repoint. Same no-lock-marker situation as
+        // the override branch (matrix: 0.2.37–0.5.0 fail, 0.5.16+ pass) —
+        // advise rather than refuse.
+        advisories.push(VendorWarning::new(
+            "pypi_uv_constraints_require_uv_0_5_6",
+            format!(
+                "[manifest] constraints for {canon_name} were repointed at the vendored wheel, \
+                 the shape uv >= 0.5.6 writes; uv 0.2.37–0.5.3 reject it under `uv sync \
+                 --locked` (`--frozen` and a plain `uv sync` still install the patch) — pin uv \
+                 >= 0.5.6 or drop the constraint on the patched package"
+            ),
+        ));
+    }
+    for edit in constraint_edits.iter().rev() {
+        new_lock.replace_range(edit.span.clone(), &edit.new_entry);
+    }
+    for edit in constraint_edits {
+        wiring.push(record(
+            "uv.lock",
+            edit.kind,
+            WiringAction::Rewritten,
+            canon_name,
+            Some(edit.old_entry),
+            edit.new_entry,
+        ));
+    }
+
     // ── commit: pyproject first, then the lock; unwind on lock failure ────
     // Mode-preserving: both are user-owned files we merely edit, so the
     // swapped-in inode must keep its permission bits rather than reset them
@@ -653,7 +731,7 @@ pub(super) async fn wire_uv(
         created_sources_table,
         lock_revision: p.lock_revision,
     };
-    Ok((wiring, meta))
+    Ok((wiring, meta, advisories))
 }
 
 /// Reverse the wiring: restore verbatim originals (or delete added fragments)
@@ -666,6 +744,16 @@ pub(super) async fn wire_uv(
 pub(super) async fn revert_uv(entry: &VendorEntry, root: &Path, dry_run: bool) -> RevertOutcome {
     let pyproject_path = root.join("pyproject.toml");
     let lock_path = root.join("uv.lock");
+    // A symlinked half would be replaced by the rename-over write: keep the
+    // artifact (the wiring still routes through it) and fail the revert.
+    if let Err((code, detail)) = refuse_symlinked_pair(root).await {
+        return RevertOutcome {
+            kept_artifact: true,
+            success: false,
+            warnings: Vec::new(),
+            error: Some(format!("{code}: {detail}")),
+        };
+    }
     let mut pyproject_text = match read_regular_to_string(&pyproject_path).await {
         Ok(t) => t,
         Err(e) => return RevertOutcome::failed(format!("cannot read pyproject.toml: {e}")),
@@ -698,7 +786,10 @@ pub(super) async fn revert_uv(entry: &VendorEntry, root: &Path, dry_run: bool) -
             )
         };
         match rec.kind.as_str() {
-            "uv_lock_package" | "uv_lock_requires_dist" | "uv_lock_requires_dev" => {
+            "uv_lock_package"
+            | "uv_lock_requires_dist"
+            | "uv_lock_requires_dev"
+            | "uv_lock_manifest_constraints" => {
                 match replace_fragment(&lock_text, new_text, original_text) {
                     Some(t) => lock_text = t,
                     None => {
@@ -724,10 +815,12 @@ pub(super) async fn revert_uv(entry: &VendorEntry, root: &Path, dry_run: bool) -
                     };
                     // A created [manifest] section was inserted with a blank
                     // separator line; a created overrides key is one line.
+                    // Both were terminated with the lock's own newline.
+                    let nl = newline_of(&lock_text);
                     let removed = if new.starts_with("[manifest]") {
-                        remove_substring(&lock_text, &format!("{new}\n\n"))
+                        remove_substring(&lock_text, &format!("{new}{nl}{nl}"))
                     } else {
-                        remove_substring(&lock_text, &format!("{new}\n"))
+                        remove_substring(&lock_text, &format!("{new}{nl}"))
                     };
                     match removed {
                         Some(t) => lock_text = t,
@@ -863,6 +956,39 @@ pub(super) async fn revert_uv(entry: &VendorEntry, root: &Path, dry_run: bool) -
 
 // ── helpers ──────────────────────────────────────────────────────────────
 
+/// Refuse when `pyproject.toml` or `uv.lock` is itself a symlink. The
+/// writers stage a replacement next to the path and rename over it, which
+/// would REPLACE the link with a regular file — the target left stale, git
+/// showing a typechange — so both wire and revert check before any write
+/// (uv itself writes through the link). `Err` names the offending file.
+async fn refuse_symlinked_pair(root: &Path) -> Result<(), (&'static str, String)> {
+    for name in ["pyproject.toml", "uv.lock"] {
+        if crate::utils::fs::is_symlink(&root.join(name)).await {
+            return Err((
+                "pypi_uv_symlink_unsupported",
+                format!(
+                    "{name} is a symbolic link; the atomic rewrite would replace the link with \
+                     a regular file and leave its target stale — vendor the real file's \
+                     directory instead"
+                ),
+            ));
+        }
+    }
+    Ok(())
+}
+
+/// The lock's line terminator. uv writes LF, but git autocrlf on Windows
+/// hands us a CRLF file; every fragment we splice, append or remove must be
+/// built with the file's own terminator or the lock comes back with mixed
+/// endings and revert's exact-text removals miss.
+fn newline_of(text: &str) -> &'static str {
+    if text.contains("\r\n") {
+        "\r\n"
+    } else {
+        "\n"
+    }
+}
+
 /// Walk/create the table chain, marking CREATED intermediates implicit so
 /// they never render stray `[tool]` headers.
 fn ensure_table<'a>(
@@ -934,13 +1060,17 @@ fn rewrite_target_package_unit(
     wheel_sha256_hex: &str,
     metadata_block: Option<&str>,
 ) -> Result<(String, String), (&'static str, String)> {
+    let nl = newline_of(lock_text);
     let span = find_unit_span(lock_text, |lines| unit_has_name(lines, canon)).ok_or_else(|| {
         (
             "pypi_uv_lock_package_missing",
             format!("uv.lock has no [[package]] entry for {canon}"),
         )
     })?;
-    let old_unit = lock_text[span].to_string();
+    // `find_unit_span` ends at the last line's content, which in a CRLF lock
+    // is its trailing `\r`; keep the fragment CR-free at both ends so the
+    // rebuilt unit splices back in front of the same `\r\n`.
+    let old_unit = lock_text[span].trim_end_matches('\r').to_string();
     let unit: Vec<&str> = old_unit.lines().collect();
     let wheels_lines = [
         "wheels = [".to_string(),
@@ -988,12 +1118,18 @@ fn rewrite_target_package_unit(
         }
         out.splice(pos..pos, wheels_lines.iter().cloned());
     }
-    let mut new_unit = out.join("\n");
+    let mut new_unit = out.join(nl);
     if let Some(block) = metadata_block {
         // uv emits [package.metadata] as a sub-table after the [[package]]
         // body, separated by one blank line (fixture shape: `]\n\n[package…`).
-        new_unit.push_str("\n\n");
-        new_unit.push_str(block);
+        // The block is rendered LF; re-terminate it for a CRLF lock.
+        new_unit.push_str(nl);
+        new_unit.push_str(nl);
+        if nl == "\n" {
+            new_unit.push_str(block);
+        } else {
+            new_unit.push_str(&block.replace('\n', nl));
+        }
     }
     Ok((old_unit, new_unit))
 }
@@ -1009,18 +1145,23 @@ struct RequiresDistEdit {
     kind: &'static str,
 }
 
-/// Find + transform EVERY root-package metadata entry for `canon`: the
-/// `[package.metadata]` `requires-dist` array (project.dependencies /
-/// optional-dependencies) AND each `[package.metadata.requires-dev]` group
-/// array (PEP 735 `[dependency-groups]` — uv records group deps there, never
-/// in requires-dist, and rewrites ALL entries to the path shape when a
-/// source applies; spike-verified against uv 0.11.19). Each entry:
-/// `{ name = "x", specifier = "==v" }` → `{ name = "x", path = "<rel>" }`
-/// (uv DROPS the specifier for path sources — recorded for revert). Returns
-/// absolute byte spans, ascending, so the caller splices by range, never by
-/// string search (a bare `{ name = "x" }` entry would collide with
-/// `dependencies` arrays elsewhere in the lock). requires-dev fragments span
-/// the whole `<group> = […]` line so identically-pinned groups stay
+/// Find + transform EVERY root-package metadata entry for `canon`: each
+/// matching element of the `[package.metadata]` `requires-dist` array
+/// (project.dependencies / optional-dependencies — a package in both has
+/// TWO entries, the extra's with `marker = "extra == '…'"`) AND each
+/// `[package.metadata.requires-dev]` group array (PEP 735
+/// `[dependency-groups]` and the legacy `[tool.uv] dev-dependencies` — uv
+/// records those there, never in requires-dist). uv rewrites ALL of them to
+/// the path shape when a source applies (verified against uv 0.11.19 and
+/// 0.12.15), so one left with its specifier keeps `--locked` red. Each
+/// entry: `{ name = "x", specifier = "==v" }` → `{ name = "x", path =
+/// "<rel>" }` (uv DROPS the specifier for path sources — recorded for
+/// revert). Returns absolute byte spans, ascending and non-overlapping, so
+/// the caller splices by range, never by string search (a bare `{ name = "x"
+/// }` entry would collide with `dependencies` arrays elsewhere in the lock).
+/// Each requires-dist element is its own edit (one wiring record per
+/// element); a requires-dev fragment spans the whole `<group> = […]` line
+/// with every matching element rewritten, so identically-pinned groups stay
 /// distinguishable when revert matches fragments by text.
 fn rewrite_root_metadata_entries(
     lock_text: &str,
@@ -1035,6 +1176,21 @@ fn rewrite_root_metadata_entries(
     })?;
     let unit_start = unit_span.start;
     let unit_text = &lock_text[unit_span];
+    // uv 0.2.35 and 0.2.36 — the first `[[package]]`-grammar releases — wrote
+    // no `[package.metadata]` at all (it arrived in 0.2.37). There is no
+    // requires-dist entry to repoint and nothing for `--locked` to compare;
+    // the package unit's source plus the pyproject `[tool.uv.sources]` entry
+    // carry the redirect alone. A lock that HAS metadata but lacks the entry
+    // is a stale lock and still refuses below.
+    //
+    // "No metadata" means neither the bare header NOR any `[package.metadata.`
+    // sub-table: `"[package.metadata.requires-dev]".contains("[package.metadata]")`
+    // is false (`.` vs `]`), so keying on the bare header alone would
+    // silently skip the requires-dev repoint should a uv release ever omit
+    // the empty header line — a stale specifier with no refusal.
+    if !unit_text.contains("[package.metadata]") && !unit_text.contains("[package.metadata.") {
+        return Ok(Vec::new());
+    }
     let needle = format!("name = \"{canon}\"");
     let mut edits: Vec<RequiresDistEdit> = Vec::new();
 
@@ -1058,6 +1214,10 @@ fn rewrite_root_metadata_entries(
                 continue;
             }
             let (new_entry, specifier) = path_source_entry(entry, rel_wheel);
+            // No early exit: a package in both project.dependencies and an
+            // optional-dependencies extra has TWO entries here (the second
+            // carries `marker = "extra == '…'"`) and uv repoints both; one
+            // left with its specifier keeps `--locked` red.
             edits.push(RequiresDistEdit {
                 span: (unit_start + arr_open + s)..(unit_start + arr_open + e),
                 old_entry: entry.to_string(),
@@ -1065,7 +1225,6 @@ fn rewrite_root_metadata_entries(
                 specifier,
                 kind: "uv_lock_requires_dist",
             });
-            break;
         }
     }
 
@@ -1088,28 +1247,39 @@ fn rewrite_root_metadata_entries(
                 )
             })?;
             let array_text = &unit_text[arr_open..arr_end];
+            // Rebuild the whole group array with EVERY matching element
+            // repointed (a group may name the package twice under different
+            // markers), so one group is always one non-overlapping edit.
+            let mut new_array = String::with_capacity(array_text.len());
+            let mut last = 0;
+            let mut specifier: Option<String> = None;
+            let mut matched = false;
             for (s, e) in top_level_brace_groups(array_text) {
                 let entry = &array_text[s..e];
                 if !entry.contains(&needle) {
                     continue;
                 }
-                let (new_entry, specifier) = path_source_entry(entry, rel_wheel);
+                let (new_entry, spec) = path_source_entry(entry, rel_wheel);
+                if specifier.is_none() {
+                    specifier = spec;
+                }
+                new_array.push_str(&array_text[last..s]);
+                new_array.push_str(&new_entry);
+                last = e;
+                matched = true;
+            }
+            if matched {
+                new_array.push_str(&array_text[last..]);
                 // Fragment from the group key so revert's text match can't
                 // confuse two groups pinning the same entry.
                 let key_start = unit_text[..arr_open].rfind('\n').map_or(0, |i| i + 1);
                 edits.push(RequiresDistEdit {
                     span: (unit_start + key_start)..(unit_start + arr_end),
                     old_entry: unit_text[key_start..arr_end].to_string(),
-                    new_entry: format!(
-                        "{}{}{}",
-                        &unit_text[key_start..arr_open + s],
-                        new_entry,
-                        &unit_text[arr_open + e..arr_end]
-                    ),
+                    new_entry: format!("{}{}", &unit_text[key_start..arr_open], new_array),
                     specifier,
                     kind: "uv_lock_requires_dev",
                 });
-                break;
             }
             cursor = arr_end;
         }
@@ -1127,6 +1297,92 @@ fn rewrite_root_metadata_entries(
     Ok(edits)
 }
 
+/// Find + transform every `[manifest] constraints` / `build-constraints`
+/// element naming `canon` (`[tool.uv] constraint-dependencies` /
+/// `build-constraint-dependencies`). uv >= 0.5.6 re-serializes a sourced
+/// package's element as `{ name, path }` (specifier dropped — uv 0.12.15
+/// ground truth), so an element left with its specifier keeps `uv lock
+/// --check` / `uv sync --locked` at exit 2 and a plain sync churns the
+/// lock. One edit per key, spanning the whole `<key> = […]` line with every
+/// matching element rewritten: the key prefix keeps revert's text match from
+/// confusing the element with a byte-identical requires-dist one. A lock
+/// without `[manifest]` or without the keys yields no edits (most locks).
+fn rewrite_manifest_constraints(
+    lock_text: &str,
+    canon: &str,
+    rel_wheel: &str,
+) -> Result<Vec<RequiresDistEdit>, (&'static str, String)> {
+    let index = line_index(lock_text);
+    let Some(h) = index.iter().position(|(_, l)| l.trim_end() == "[manifest]") else {
+        return Ok(Vec::new());
+    };
+    // Section spans until the next top-level header.
+    let section_end_line = index[h + 1..]
+        .iter()
+        .position(|(_, l)| l.starts_with('['))
+        .map(|i| h + 1 + i)
+        .unwrap_or(index.len());
+    let section_start = index[h].0;
+    let section_end = index
+        .get(section_end_line)
+        .map(|(off, _)| *off)
+        .unwrap_or(lock_text.len());
+    let section = &lock_text[section_start..section_end];
+    let needle = format!("name = \"{canon}\"");
+    let mut edits: Vec<RequiresDistEdit> = Vec::new();
+
+    for key in ["constraints", "build-constraints"] {
+        let prefix = format!("{key} = [");
+        // Keys sit at line start, so `constraints = [` can never match inside
+        // `build-constraints = [`.
+        let Some(line_off) = line_index(section)
+            .iter()
+            .find(|(_, l)| l.starts_with(&prefix))
+            .map(|(off, _)| *off)
+        else {
+            continue;
+        };
+        let arr_open = line_off + prefix.len() - 1;
+        let arr_end = balanced_span(section, arr_open).ok_or_else(|| {
+            (
+                "pypi_uv_lock_parse_failed",
+                format!("uv.lock [manifest] {key} array is unbalanced"),
+            )
+        })?;
+        let array_text = &section[arr_open..arr_end];
+        let mut new_array = String::with_capacity(array_text.len());
+        let mut last = 0;
+        let mut specifier: Option<String> = None;
+        let mut matched = false;
+        for (s, e) in top_level_brace_groups(array_text) {
+            let entry = &array_text[s..e];
+            if !entry.contains(&needle) {
+                continue;
+            }
+            let (new_entry, spec) = path_source_entry(entry, rel_wheel);
+            if specifier.is_none() {
+                specifier = spec;
+            }
+            new_array.push_str(&array_text[last..s]);
+            new_array.push_str(&new_entry);
+            last = e;
+            matched = true;
+        }
+        if !matched {
+            continue;
+        }
+        new_array.push_str(&array_text[last..]);
+        edits.push(RequiresDistEdit {
+            span: (section_start + line_off)..(section_start + arr_end),
+            old_entry: section[line_off..arr_end].to_string(),
+            new_entry: format!("{}{}", &section[line_off..arr_open], new_array),
+            specifier,
+            kind: "uv_lock_manifest_constraints",
+        });
+    }
+    Ok(edits)
+}
+
 /// Build the path-source requires-dist entry from the registry one: keep
 /// every other key (extras, markers) in place, drop `specifier`, append
 /// `path` — matching uv's own serialization of a sources-path dep.
@@ -1160,6 +1416,9 @@ fn add_manifest_override(
     rel_wheel: &str,
 ) -> Result<(WiringRecord, String), (&'static str, String)> {
     let element = format!("{{ name = \"{canon}\", path = \"{rel_wheel}\" }}");
+    // Every created/spliced fragment is built with the lock's own terminator
+    // (revert removes `{new}{nl}` / `{new}{nl}{nl}` with the same detection).
+    let nl = newline_of(lock_text);
     let index = line_index(lock_text);
     let manifest_line = index.iter().position(|(_, l)| l.trim_end() == "[manifest]");
 
@@ -1176,9 +1435,9 @@ fn add_manifest_override(
                     "uv.lock has no [[package]] entries".to_string(),
                 )
             })?;
-        let section = format!("[manifest]\noverrides = [{element}]");
+        let section = format!("[manifest]{nl}overrides = [{element}]");
         let mut text = lock_text.to_string();
-        text.insert_str(first_pkg, &format!("{section}\n\n"));
+        text.insert_str(first_pkg, &format!("{section}{nl}{nl}"));
         return Ok((
             record(
                 "uv.lock",
@@ -1217,7 +1476,7 @@ fn add_manifest_override(
         let new_array = if old_array.contains('\n') {
             // multi-line: add an indented element before the closing bracket
             let body = &old_array[..old_array.rfind(']').unwrap_or(old_array.len())];
-            format!("{body}    {element},\n]")
+            format!("{body}    {element},{nl}]")
         } else if old_array[1..old_array.len() - 1].trim().is_empty() {
             // `overrides = []` (hand-edited; uv omits the key when empty):
             // no existing element to comma-separate from
@@ -1251,7 +1510,7 @@ fn add_manifest_override(
         .map(|(off, _)| *off)
         .unwrap_or(lock_text.len());
     let mut text = lock_text.to_string();
-    text.insert_str(insert_at, &format!("{line}\n"));
+    text.insert_str(insert_at, &format!("{line}{nl}"));
     Ok((
         record(
             "uv.lock",
@@ -1748,7 +2007,7 @@ wheels = [
         assert!(p.warnings.is_empty());
         assert_eq!(classify_dependency(&p, "six"), UvDepClass::Direct);
 
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -1795,7 +2054,7 @@ wheels = [
         let p = load_uv_project(tmp.path()).await.unwrap();
         assert_eq!(classify_dependency(&p, "six"), UvDepClass::Transitive);
 
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -2072,7 +2331,7 @@ wheels = [
     async fn revert_direct_restores_originals_byte_identically() {
         let tmp = write_pair(DIRECT_REGISTRY_PYPROJECT, DIRECT_REGISTRY_LOCK).await;
         let p = load_uv_project(tmp.path()).await.unwrap();
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -2101,7 +2360,7 @@ wheels = [
     async fn revert_override_restores_originals_byte_identically() {
         let tmp = write_pair(TRANSITIVE_REGISTRY_PYPROJECT, TRANSITIVE_REGISTRY_LOCK).await;
         let p = load_uv_project(tmp.path()).await.unwrap();
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -2188,7 +2447,7 @@ wheels = [
         };
 
         let p = load_uv_project(tmp.path()).await.unwrap();
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -2222,7 +2481,7 @@ wheels = [
     async fn revert_dry_run_changes_nothing() {
         let tmp = write_pair(DIRECT_REGISTRY_PYPROJECT, DIRECT_REGISTRY_LOCK).await;
         let p = load_uv_project(tmp.path()).await.unwrap();
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -2250,7 +2509,7 @@ wheels = [
     async fn revert_warns_and_skips_on_drifted_lock_fragment() {
         let tmp = write_pair(DIRECT_REGISTRY_PYPROJECT, DIRECT_REGISTRY_LOCK).await;
         let p = load_uv_project(tmp.path()).await.unwrap();
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -2408,6 +2667,24 @@ wheels = [
 
     // ── path-source [package.metadata] reconstruction ──────────────────
 
+    /// uv 0.2.35/0.2.36 locks have a root `[[package]]` but no
+    /// `[package.metadata]`: the metadata step is a no-op rather than a
+    /// refusal. A lock that carries metadata without the entry still refuses.
+    #[test]
+    fn root_metadata_rewrite_is_a_noop_for_locks_without_package_metadata() {
+        let without = "version = 1\nrequires-python = \">=3.9\"\n\n[[package]]\nname = \"fixture\"\nversion = \"0.1.0\"\nsource = { editable = \".\" }\ndependencies = [\n    { name = \"six\" },\n]\n\n[[package]]\nname = \"six\"\nversion = \"1.16.0\"\nsource = { registry = \"https://pypi.org/simple\" }\nwheels = [\n    { url = \"https://files.pythonhosted.org/six-1.16.0-py2.py3-none-any.whl\", hash = \"sha256:old\" },\n]\n";
+        let edits = rewrite_root_metadata_entries(without, "six", REL_WHEEL).unwrap();
+        assert!(edits.is_empty());
+        let stale = without.replace(
+            "dependencies = [\n    { name = \"six\" },\n]\n",
+            "dependencies = [\n    { name = \"six\" },\n]\n\n[package.metadata]\nrequires-dist = [{ name = \"other\", specifier = \"==1\" }]\n",
+        );
+        let err = rewrite_root_metadata_entries(&stale, "six", REL_WHEEL)
+            .err()
+            .expect("metadata without the entry must refuse");
+        assert_eq!(err.0, "pypi_uv_lock_package_missing");
+    }
+
     #[test]
     fn parse_requires_dist_pulls_apart_name_extras_specifier_marker() {
         // extra-gated dep with a bare specifier
@@ -2592,7 +2869,7 @@ wheels = [
 
         let p = load_uv_project(tmp.path()).await.unwrap();
         assert_eq!(classify_dependency(&p, "widget"), UvDepClass::Direct);
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "widget",
@@ -2654,7 +2931,7 @@ wheels = [
         );
         let tmp = write_pair(TRANSITIVE_REGISTRY_PYPROJECT, &empty_overrides_lock).await;
         let p = load_uv_project(tmp.path()).await.unwrap();
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -2883,7 +3160,7 @@ wheels = [
         let p = load_uv_project(tmp.path()).await.unwrap();
         assert_eq!(classify_dependency(&p, "six"), UvDepClass::Direct);
 
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -2932,7 +3209,7 @@ wheels = [
         let p = load_uv_project(tmp.path()).await.unwrap();
         assert_eq!(classify_dependency(&p, "six"), UvDepClass::Direct);
 
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -3067,7 +3344,7 @@ wheels = [
         assert!(p.warnings.is_empty(), "{:?}", p.warnings);
         assert_eq!(p.lock_revision, None);
 
-        let (_, meta) = wire_uv(
+        let (_, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -3138,7 +3415,7 @@ wheels = [
         let p = load_uv_project(tmp.path()).await.unwrap();
         assert_eq!(classify_dependency(&p, "six"), UvDepClass::Transitive);
 
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -3198,7 +3475,7 @@ wheels = [
         );
         let tmp = write_pair(TRANSITIVE_REGISTRY_PYPROJECT, &input_lock).await;
         let p = load_uv_project(tmp.path()).await.unwrap();
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -3257,7 +3534,7 @@ wheels = [
         );
         let tmp = write_pair(TRANSITIVE_REGISTRY_PYPROJECT, &input_lock).await;
         let p = load_uv_project(tmp.path()).await.unwrap();
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -3307,7 +3584,7 @@ wheels = [
         );
         let tmp = write_pair(TRANSITIVE_REGISTRY_PYPROJECT, &input_lock).await;
         let p = load_uv_project(tmp.path()).await.unwrap();
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -3366,7 +3643,7 @@ wheels = [
         );
         let tmp = write_pair(TRANSITIVE_REGISTRY_PYPROJECT, &input_lock).await;
         let p = load_uv_project(tmp.path()).await.unwrap();
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -3431,7 +3708,7 @@ wheels = [
     async fn revert_warns_and_skips_when_sources_line_was_edited() {
         let tmp = write_pair(DIRECT_REGISTRY_PYPROJECT, DIRECT_REGISTRY_LOCK).await;
         let p = load_uv_project(tmp.path()).await.unwrap();
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -3494,7 +3771,7 @@ wheels = [
         ] {
             let tmp = write_pair(registry_py, registry_lock).await;
             let p = load_uv_project(tmp.path()).await.unwrap();
-            let (wiring, meta) = wire_uv(
+            let (wiring, meta, _) = wire_uv(
                 &p,
                 tmp.path(),
                 target,
@@ -3540,7 +3817,7 @@ wheels = [
     async fn revert_pypi_converged_uv_cleans_up_the_artifact() {
         let tmp = write_pair(DIRECT_REGISTRY_PYPROJECT, DIRECT_REGISTRY_LOCK).await;
         let p = load_uv_project(tmp.path()).await.unwrap();
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -3588,7 +3865,7 @@ wheels = [
     async fn revert_pypi_drifted_uv_keeps_artifact() {
         let tmp = write_pair(DIRECT_REGISTRY_PYPROJECT, DIRECT_REGISTRY_LOCK).await;
         let p = load_uv_project(tmp.path()).await.unwrap();
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -3645,7 +3922,7 @@ wheels = [
     async fn revert_warns_and_skips_when_added_override_line_was_edited() {
         let tmp = write_pair(TRANSITIVE_REGISTRY_PYPROJECT, TRANSITIVE_REGISTRY_LOCK).await;
         let p = load_uv_project(tmp.path()).await.unwrap();
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -3776,7 +4053,7 @@ wheels = [
         use std::os::unix::fs::PermissionsExt;
         let tmp = write_pair(DIRECT_REGISTRY_PYPROJECT, DIRECT_REGISTRY_LOCK).await;
         let p = load_uv_project(tmp.path()).await.unwrap();
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -3846,7 +4123,7 @@ wheels = [
 
         let tmp = write_pair(DIRECT_REGISTRY_PYPROJECT, &sdist_only_lock).await;
         let p = load_uv_project(tmp.path()).await.unwrap();
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -4290,7 +4567,7 @@ wheels = [
     async fn revert_warns_when_created_manifest_section_still_routes_after_reshape() {
         let tmp = write_pair(TRANSITIVE_REGISTRY_PYPROJECT, TRANSITIVE_REGISTRY_LOCK).await;
         let p = load_uv_project(tmp.path()).await.unwrap();
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -4360,7 +4637,7 @@ wheels = [
         );
         let tmp = write_pair(TRANSITIVE_REGISTRY_PYPROJECT, &input_lock).await;
         let p = load_uv_project(tmp.path()).await.unwrap();
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -4399,7 +4676,7 @@ wheels = [
         );
         let tmp = write_pair(&pyproject, TRANSITIVE_REGISTRY_LOCK).await;
         let p = load_uv_project(tmp.path()).await.unwrap();
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -4434,7 +4711,7 @@ wheels = [
         );
         let tmp = write_pair(&pyproject, TRANSITIVE_REGISTRY_LOCK).await;
         let p = load_uv_project(tmp.path()).await.unwrap();
-        let (wiring, meta) = wire_uv(
+        let (wiring, meta, _) = wire_uv(
             &p,
             tmp.path(),
             "six",
@@ -4636,4 +4913,623 @@ wheels = [
         assert_eq!(err.0, "pypi_uv_lock_parse_failed");
         assert!(err.1.contains("overrides array is unbalanced"), "{}", err.1);
     }
+
+    // ── legacy `[tool.uv] dev-dependencies` (uv 0.12.15 ground truth) ───
+    // uv still honours the deprecated array (with a warning) and records it
+    // EXACTLY like `[dependency-groups] dev`: a `[package.dev-dependencies]
+    // dev` edge plus a `[package.metadata.requires-dev] dev` entry, never a
+    // requires-dist one. The lock shapes are therefore the dev-group ones.
+
+    const TOOL_UV_DEV_REGISTRY_PYPROJECT: &str = r#"[project]
+name = "proj"
+version = "0.1.0"
+requires-python = ">=3.10"
+dependencies = []
+
+[tool.uv]
+dev-dependencies = ["six==1.16.0"]
+"#;
+
+    const TOOL_UV_DEV_PATH_PYPROJECT: &str = r#"[project]
+name = "proj"
+version = "0.1.0"
+requires-python = ">=3.10"
+dependencies = []
+
+[tool.uv]
+dev-dependencies = ["six==1.16.0"]
+
+[tool.uv.sources]
+six = { path = ".socket/vendor/pypi/9f6b2c4e-1d3a-4f6b-8c2d-7e5a9b1c3d5f/six-1.16.0-py2.py3-none-any.whl" }
+"#;
+
+    /// A target declared ONLY in the legacy `[tool.uv] dev-dependencies`
+    /// array is a Direct dependency: `[tool.uv.sources]` applies to it and
+    /// the lock keeps it in `[package.metadata.requires-dev]`. Classifying
+    /// it Transitive took the override branch and left the requires-dev
+    /// `specifier` in place, so every uv >= 0.2.37 `uv sync --locked` /
+    /// `uv lock --check` failed after a "successful" vendored scan (and a
+    /// plain `uv sync` on 0.2.37/0.4.30 reinstalled the pristine wheel).
+    #[tokio::test]
+    async fn tool_uv_dev_dependencies_classify_direct_and_repoint_requires_dev() {
+        let tmp = write_pair(TOOL_UV_DEV_REGISTRY_PYPROJECT, DEV_GROUP_REGISTRY_LOCK).await;
+        let p = load_uv_project(tmp.path()).await.unwrap();
+        assert_eq!(
+            classify_dependency(&p, "six"),
+            UvDepClass::Direct,
+            "[tool.uv] dev-dependencies is a declaration surface sources apply to"
+        );
+
+        let (wiring, meta, _) = wire_uv(
+            &p,
+            tmp.path(),
+            "six",
+            "1.16.0",
+            REL_WHEEL,
+            WHEEL_NAME,
+            WHEEL_SHA,
+            UUID,
+        )
+        .await
+        .unwrap();
+
+        let kinds: Vec<&str> = wiring.iter().map(|w| w.kind.as_str()).collect();
+        assert_eq!(
+            kinds,
+            vec!["uv_sources_entry", "uv_lock_package", "uv_lock_requires_dev"],
+            "a requires-dev repoint and NO override record"
+        );
+        assert_eq!(meta.dep_class, "direct");
+        assert_eq!(meta.original_specifier.as_deref(), Some("==1.16.0"));
+        let (pyproject, lock) = read_pair(tmp.path()).await;
+        assert!(
+            !pyproject.contains("override-dependencies"),
+            "no override pin may be layered on a declared dependency:\n{pyproject}"
+        );
+        assert_eq!(pyproject, TOOL_UV_DEV_PATH_PYPROJECT);
+        assert_eq!(
+            lock, DEV_GROUP_PATH_LOCK,
+            "the requires-dev entry must carry `path` (uv 0.12.15 shape)"
+        );
+
+        let entry = entry_for(wiring, meta);
+        let outcome = revert_uv(&entry, tmp.path(), false).await;
+        assert!(outcome.success, "{:?}", outcome.error);
+        assert!(outcome.warnings.is_empty(), "{:?}", outcome.warnings);
+        let (pyproject, lock) = read_pair(tmp.path()).await;
+        assert_eq!(pyproject, TOOL_UV_DEV_REGISTRY_PYPROJECT);
+        assert_eq!(lock, DEV_GROUP_REGISTRY_LOCK);
+    }
+
+    // ── extras duplicate (uv 0.12.15 ground truth) ───────────────────────
+    // A package in BOTH project.dependencies and an optional-dependencies
+    // extra yields two requires-dist entries (the second carries
+    // `marker = "extra == '…'"`); a path source repoints BOTH.
+
+    const EXTRAS_DUP_REGISTRY_PYPROJECT: &str = r#"[project]
+name = "proj"
+version = "0.1.0"
+requires-python = ">=3.10"
+dependencies = ["six==1.16.0"]
+
+[project.optional-dependencies]
+socks = ["six==1.16.0"]
+"#;
+
+    const EXTRAS_DUP_REGISTRY_LOCK: &str = r#"version = 1
+revision = 3
+requires-python = ">=3.10"
+
+[[package]]
+name = "proj"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "six" },
+]
+
+[package.optional-dependencies]
+socks = [
+    { name = "six" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "six", specifier = "==1.16.0" },
+    { name = "six", marker = "extra == 'socks'", specifier = "==1.16.0" },
+]
+provides-extras = ["socks"]
+
+[[package]]
+name = "six"
+version = "1.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/71/39/171f1c67cd00715f190ba0b100d606d440a28c93c7714febeca8b79af85e/six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926", size = 34041, upload-time = "2021-05-05T14:18:18.379Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d9/5a/e7c31adbe875f2abbb91bd84cf2dc52d792b5a01506781dbcf25c91daf11/six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254", size = 11053, upload-time = "2021-05-05T14:18:17.237Z" },
+]
+"#;
+
+    const EXTRAS_DUP_PATH_LOCK: &str = r#"version = 1
+revision = 3
+requires-python = ">=3.10"
+
+[[package]]
+name = "proj"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "six" },
+]
+
+[package.optional-dependencies]
+socks = [
+    { name = "six" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "six", path = ".socket/vendor/pypi/9f6b2c4e-1d3a-4f6b-8c2d-7e5a9b1c3d5f/six-1.16.0-py2.py3-none-any.whl" },
+    { name = "six", marker = "extra == 'socks'", path = ".socket/vendor/pypi/9f6b2c4e-1d3a-4f6b-8c2d-7e5a9b1c3d5f/six-1.16.0-py2.py3-none-any.whl" },
+]
+provides-extras = ["socks"]
+
+[[package]]
+name = "six"
+version = "1.16.0"
+source = { path = ".socket/vendor/pypi/9f6b2c4e-1d3a-4f6b-8c2d-7e5a9b1c3d5f/six-1.16.0-py2.py3-none-any.whl" }
+wheels = [
+    { filename = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254" },
+]
+"#;
+
+    /// Both requires-dist entries for one package (bare + extra-marker) are
+    /// repointed — one wiring record each — and revert restores both. The
+    /// first-match `break` left the marker entry with its `specifier`, so
+    /// `uv lock --check` / `uv sync --locked` failed after vendoring.
+    #[tokio::test]
+    async fn duplicate_requires_dist_entries_all_repointed() {
+        let tmp = write_pair(EXTRAS_DUP_REGISTRY_PYPROJECT, EXTRAS_DUP_REGISTRY_LOCK).await;
+        let p = load_uv_project(tmp.path()).await.unwrap();
+        assert_eq!(classify_dependency(&p, "six"), UvDepClass::Direct);
+
+        let (wiring, meta, _) = wire_uv(
+            &p,
+            tmp.path(),
+            "six",
+            "1.16.0",
+            REL_WHEEL,
+            WHEEL_NAME,
+            WHEEL_SHA,
+            UUID,
+        )
+        .await
+        .unwrap();
+
+        let kinds: Vec<&str> = wiring.iter().map(|w| w.kind.as_str()).collect();
+        assert_eq!(
+            kinds,
+            vec![
+                "uv_sources_entry",
+                "uv_lock_package",
+                "uv_lock_requires_dist",
+                "uv_lock_requires_dist"
+            ],
+            "one record per repointed requires-dist entry"
+        );
+        let (_, lock) = read_pair(tmp.path()).await;
+        assert_eq!(
+            lock, EXTRAS_DUP_PATH_LOCK,
+            "both the bare and the extra-marker entries must carry `path`"
+        );
+
+        let entry = entry_for(wiring, meta);
+        let outcome = revert_uv(&entry, tmp.path(), false).await;
+        assert!(outcome.success, "{:?}", outcome.error);
+        assert!(outcome.warnings.is_empty(), "{:?}", outcome.warnings);
+        let (pyproject, lock) = read_pair(tmp.path()).await;
+        assert_eq!(pyproject, EXTRAS_DUP_REGISTRY_PYPROJECT);
+        assert_eq!(lock, EXTRAS_DUP_REGISTRY_LOCK);
+    }
+
+    /// uv 0.2.35–0.5.3 do NOT apply `[tool.uv.sources]` to
+    /// override-dependencies: a transitive target wired through the override
+    /// branch is silently reinstalled from the registry by a plain `uv sync`
+    /// on those releases, and no lock-shape marker separates 0.5.3 from
+    /// 0.5.6, so an offline refusal is impossible. The branch must surface a
+    /// stable advisory; the Direct branch must stay silent.
+    #[tokio::test]
+    async fn override_branch_emits_uv_version_advisory() {
+        let tmp = write_pair(TRANSITIVE_REGISTRY_PYPROJECT, TRANSITIVE_REGISTRY_LOCK).await;
+        let p = load_uv_project(tmp.path()).await.unwrap();
+        let (_, meta, advisories) = wire_uv(
+            &p,
+            tmp.path(),
+            "six",
+            "1.16.0",
+            REL_WHEEL,
+            WHEEL_NAME,
+            WHEEL_SHA,
+            UUID,
+        )
+        .await
+        .unwrap();
+        assert_eq!(meta.dep_class, "override");
+        let codes: Vec<&str> = advisories.iter().map(|w| w.code).collect();
+        assert_eq!(codes, vec!["pypi_uv_override_requires_uv_0_5_6"]);
+        let detail = &advisories[0].detail;
+        assert!(
+            detail.contains("0.5.6") && detail.contains("override-dependencies"),
+            "{detail}"
+        );
+
+        let tmp = write_pair(DIRECT_REGISTRY_PYPROJECT, DIRECT_REGISTRY_LOCK).await;
+        let p = load_uv_project(tmp.path()).await.unwrap();
+        let (_, meta, advisories) = wire_uv(
+            &p,
+            tmp.path(),
+            "six",
+            "1.16.0",
+            REL_WHEEL,
+            WHEEL_NAME,
+            WHEEL_SHA,
+            UUID,
+        )
+        .await
+        .unwrap();
+        assert_eq!(meta.dep_class, "direct");
+        assert!(
+            advisories.is_empty(),
+            "a direct dependency needs no override advisory: {advisories:?}"
+        );
+    }
+
+    // ── [tool.uv] constraint-dependencies (uv 0.12.15 ground truth) ─────
+    // A constrained package is recorded in `[manifest] constraints`
+    // (resp. `build-constraints` for build-constraint-dependencies) as
+    // `{ name, specifier }`; once the package has a path source uv >= 0.5.6
+    // re-serializes the element as `{ name, path }` — a stale specifier
+    // keeps `uv lock --check` / `uv sync --locked` at exit 2.
+
+    const CONSTRAINTS_REGISTRY_PYPROJECT: &str = r#"[project]
+name = "proj"
+version = "0.1.0"
+requires-python = ">=3.10"
+dependencies = ["six==1.16.0"]
+
+[tool.uv]
+constraint-dependencies = ["six==1.16.0"]
+"#;
+
+    const CONSTRAINTS_PATH_PYPROJECT: &str = r#"[project]
+name = "proj"
+version = "0.1.0"
+requires-python = ">=3.10"
+dependencies = ["six==1.16.0"]
+
+[tool.uv]
+constraint-dependencies = ["six==1.16.0"]
+
+[tool.uv.sources]
+six = { path = ".socket/vendor/pypi/9f6b2c4e-1d3a-4f6b-8c2d-7e5a9b1c3d5f/six-1.16.0-py2.py3-none-any.whl" }
+"#;
+
+    /// `[manifest] constraints` AND `build-constraints` elements naming the
+    /// target are repointed to the path shape (one whole-line record per
+    /// key, kind `uv_lock_manifest_constraints`) and revert restores them
+    /// byte-exactly. Fixtures: the DIRECT pair with the uv 0.12.15
+    /// `[manifest]` block prepended.
+    #[tokio::test]
+    async fn constraint_dependencies_manifest_entries_repointed_and_reverted() {
+        let manifest = "[manifest]\nconstraints = [{ name = \"six\", specifier = \"==1.16.0\" }]\nbuild-constraints = [{ name = \"six\", specifier = \">=1.16\" }]\n\n";
+        let registry_lock = DIRECT_REGISTRY_LOCK.replacen("[[package]]", &format!("{manifest}[[package]]"), 1);
+        let path_manifest = format!(
+            "[manifest]\nconstraints = [{{ name = \"six\", path = \"{REL_WHEEL}\" }}]\nbuild-constraints = [{{ name = \"six\", path = \"{REL_WHEEL}\" }}]\n\n"
+        );
+        let path_lock = DIRECT_PATH_LOCK.replacen("[[package]]", &format!("{path_manifest}[[package]]"), 1);
+
+        let tmp = write_pair(CONSTRAINTS_REGISTRY_PYPROJECT, &registry_lock).await;
+        let p = load_uv_project(tmp.path()).await.unwrap();
+        let (wiring, meta, advisories) = wire_uv(
+            &p,
+            tmp.path(),
+            "six",
+            "1.16.0",
+            REL_WHEEL,
+            WHEEL_NAME,
+            WHEEL_SHA,
+            UUID,
+        )
+        .await
+        .unwrap();
+
+        // The repoint is the uv >= 0.5.6 shape; 0.2.37–0.5.3 reject it under
+        // `--locked` (matrix: 0.2.37–0.5.0 fail, 0.5.16+ pass), so it advises.
+        let codes: Vec<&str> = advisories.iter().map(|w| w.code).collect();
+        assert_eq!(codes, vec!["pypi_uv_constraints_require_uv_0_5_6"]);
+        assert!(advisories[0].detail.contains("0.5.6"), "{}", advisories[0].detail);
+
+        let (pyproject, lock) = read_pair(tmp.path()).await;
+        assert_eq!(pyproject, CONSTRAINTS_PATH_PYPROJECT);
+        assert_eq!(
+            lock, path_lock,
+            "both [manifest] constraint arrays must carry `path` (uv 0.12.15 shape)"
+        );
+        let kinds: Vec<&str> = wiring.iter().map(|w| w.kind.as_str()).collect();
+        assert_eq!(
+            kinds,
+            vec![
+                "uv_sources_entry",
+                "uv_lock_package",
+                "uv_lock_requires_dist",
+                "uv_lock_manifest_constraints",
+                "uv_lock_manifest_constraints",
+            ]
+        );
+        let constraint_records: Vec<&WiringRecord> = wiring
+            .iter()
+            .filter(|w| w.kind == "uv_lock_manifest_constraints")
+            .collect();
+        assert_eq!(
+            constraint_records[0].original.as_ref().and_then(|v| v.as_str()),
+            Some("constraints = [{ name = \"six\", specifier = \"==1.16.0\" }]"),
+            "the fragment spans the whole key line so revert cannot confuse it \
+             with an identical requires-dist element"
+        );
+        assert_eq!(
+            constraint_records[1].original.as_ref().and_then(|v| v.as_str()),
+            Some("build-constraints = [{ name = \"six\", specifier = \">=1.16\" }]")
+        );
+
+        let entry = entry_for(wiring, meta);
+        let outcome = revert_uv(&entry, tmp.path(), false).await;
+        assert!(outcome.success, "{:?}", outcome.error);
+        assert!(outcome.warnings.is_empty(), "{:?}", outcome.warnings);
+        let (pyproject, lock) = read_pair(tmp.path()).await;
+        assert_eq!(pyproject, CONSTRAINTS_REGISTRY_PYPROJECT);
+        assert_eq!(lock, registry_lock);
+    }
+
+    /// Whether `text` holds a `\n` that is not part of a `\r\n` pair.
+    fn has_bare_lf(text: &str) -> bool {
+        let bytes = text.as_bytes();
+        bytes
+            .iter()
+            .enumerate()
+            .any(|(i, &b)| b == b'\n' && (i == 0 || bytes[i - 1] != b'\r'))
+    }
+
+    /// A pure-CRLF pair (git autocrlf on Windows) must wire to a pure-CRLF
+    /// pair and revert byte-exactly. `doc.to_string()` re-emits every
+    /// pyproject newline as LF, the lock surgery joined rebuilt units and
+    /// created `[manifest]` fragments with LF (mixed endings), and revert's
+    /// hardcoded `"{new}\n"` removals then missed. Covers the Direct,
+    /// Transitive (created override + created `[manifest]`), Rewritten
+    /// override (multi-line arrays in both files) and requires-dev shapes.
+    #[tokio::test]
+    async fn crlf_pyproject_and_lock_round_trip_byte_exact() {
+        let existing_override_pyproject = format!(
+            "{TRANSITIVE_REGISTRY_PYPROJECT}\n[tool.uv]\noverride-dependencies = [\n    \"attrs==23.1.0\",\n]\n"
+        );
+        let existing_override_lock = TRANSITIVE_REGISTRY_LOCK.replacen(
+            "[[package]]",
+            "[manifest]\noverrides = [\n    { name = \"attrs\", specifier = \"==23.1.0\" },\n]\n\n[[package]]",
+            1,
+        );
+        let cases: [(&str, &str, &str); 4] = [
+            ("direct", DIRECT_REGISTRY_PYPROJECT, DIRECT_REGISTRY_LOCK),
+            (
+                "transitive",
+                TRANSITIVE_REGISTRY_PYPROJECT,
+                TRANSITIVE_REGISTRY_LOCK,
+            ),
+            (
+                "existing-override",
+                &existing_override_pyproject,
+                &existing_override_lock,
+            ),
+            ("dev-group", DEV_GROUP_REGISTRY_PYPROJECT, DEV_GROUP_REGISTRY_LOCK),
+        ];
+        for (label, pyproject_lf, lock_lf) in cases {
+            let pyproject_crlf = pyproject_lf.replace('\n', "\r\n");
+            let lock_crlf = lock_lf.replace('\n', "\r\n");
+            let tmp = write_pair(&pyproject_crlf, &lock_crlf).await;
+            let p = load_uv_project(tmp.path()).await.unwrap();
+            let (wiring, meta, _) = wire_uv(
+                &p,
+                tmp.path(),
+                "six",
+                "1.16.0",
+                REL_WHEEL,
+                WHEEL_NAME,
+                WHEEL_SHA,
+                UUID,
+            )
+            .await
+            .unwrap_or_else(|e| panic!("{label}: {e:?}"));
+
+            let (pyproject, lock) = read_pair(tmp.path()).await;
+            assert!(
+                !has_bare_lf(&pyproject),
+                "{label}: wired pyproject.toml must stay pure CRLF:\n{pyproject:?}"
+            );
+            assert!(
+                !has_bare_lf(&lock),
+                "{label}: wired uv.lock must stay pure CRLF:\n{lock:?}"
+            );
+            assert!(
+                lock.contains(REL_WHEEL) && pyproject.contains(REL_WHEEL),
+                "{label}: the pair must actually be wired"
+            );
+            // Modulo line endings the wired pair is the LF pair's wiring.
+            let tmp_lf = write_pair(pyproject_lf, lock_lf).await;
+            let p_lf = load_uv_project(tmp_lf.path()).await.unwrap();
+            wire_uv(
+                &p_lf,
+                tmp_lf.path(),
+                "six",
+                "1.16.0",
+                REL_WHEEL,
+                WHEEL_NAME,
+                WHEEL_SHA,
+                UUID,
+            )
+            .await
+            .unwrap();
+            let (pyproject_expect, lock_expect) = read_pair(tmp_lf.path()).await;
+            assert_eq!(
+                pyproject.replace("\r\n", "\n"),
+                pyproject_expect,
+                "{label}: pyproject wiring differs beyond line endings"
+            );
+            assert_eq!(
+                lock.replace("\r\n", "\n"),
+                lock_expect,
+                "{label}: lock wiring differs beyond line endings"
+            );
+
+            let entry = entry_for(wiring, meta);
+            let outcome = revert_uv(&entry, tmp.path(), false).await;
+            assert!(outcome.success, "{label}: {:?}", outcome.error);
+            assert!(
+                outcome.warnings.is_empty(),
+                "{label}: {:?}",
+                outcome.warnings
+            );
+            let (pyproject, lock) = read_pair(tmp.path()).await;
+            assert_eq!(pyproject, pyproject_crlf, "{label}: pyproject not restored");
+            assert_eq!(lock, lock_crlf, "{label}: lock not restored");
+        }
+    }
+
+    /// The `[[distribution]]` refusal names the REAL limitation measured
+    /// against the 0.1.45–0.2.34 binaries (relative path sources are
+    /// rejected by `--locked` and absolutized by `uv lock` / `uv sync`),
+    /// not the old "records absolute file paths" folklore, and points at
+    /// both exits (uv >= 0.2.35, or a requirements.txt install).
+    #[tokio::test]
+    async fn legacy_distribution_lock_refusal_names_the_real_limitation() {
+        let legacy_lock = "version = 1\nrequires-python = \">=3.9\"\n\n[[distribution]]\nname = \"proj\"\nversion = \"0.1.0\"\nsource = { editable = \".\" }\n";
+        let tmp = write_pair(DIRECT_REGISTRY_PYPROJECT, legacy_lock).await;
+        let (code, detail) = load_uv_project(tmp.path()).await.unwrap_err();
+        assert_eq!(code, "pypi_uv_legacy_lock_unsupported");
+        assert!(
+            detail.contains("`--locked` rejects relative paths")
+                && detail.contains("rewrite them to absolute ones")
+                && detail.contains("uv >=0.2.35")
+                && detail.contains("requirements.txt"),
+            "{detail}"
+        );
+        assert!(!detail.contains("record absolute"), "{detail}");
+    }
+
+    /// `"[package.metadata.requires-dev]".contains("[package.metadata]")` is
+    /// FALSE (`.` vs `]`), so a no-op gate keyed on the bare header alone
+    /// would silently skip the requires-dev repoint if a uv release ever
+    /// omitted the empty `[package.metadata]` line — a stale specifier and a
+    /// red `--locked` with no refusal. A root unit carrying ONLY the
+    /// sub-table must still have its group entry repointed.
+    #[test]
+    fn requires_dev_is_repointed_without_a_bare_package_metadata_header() {
+        let lock = DEV_GROUP_REGISTRY_LOCK.replacen("[package.metadata]\n\n", "", 1);
+        assert!(
+            !lock.contains("[package.metadata]\n"),
+            "fixture must lack the bare header"
+        );
+        let edits = rewrite_root_metadata_entries(&lock, "six", REL_WHEEL).unwrap();
+        assert_eq!(edits.len(), 1, "the requires-dev group entry must be repointed");
+        assert_eq!(edits[0].kind, "uv_lock_requires_dev");
+        assert_eq!(
+            edits[0].new_entry,
+            format!("dev = [{{ name = \"six\", path = \"{REL_WHEEL}\" }}]")
+        );
+        assert_eq!(edits[0].specifier.as_deref(), Some("==1.16.0"));
+    }
+
+    /// atomic_write_bytes_preserving_mode stages a file next to the path and
+    /// renames over it: a symlinked pyproject.toml / uv.lock would be
+    /// REPLACED by a regular file (target left stale, git shows a
+    /// typechange). Wire refuses before ANY write with
+    /// `pypi_uv_symlink_unsupported` naming the file; revert keeps the
+    /// artifact and fails. The link stays a link, its target keeps its bytes,
+    /// and nothing under `.socket/` appears.
+    #[cfg(unix)]
+    #[tokio::test]
+    async fn symlinked_uv_lock_or_pyproject_refused_before_write() {
+        for linked in ["pyproject.toml", "uv.lock"] {
+            let tmp = write_pair(DIRECT_REGISTRY_PYPROJECT, DIRECT_REGISTRY_LOCK).await;
+            let real = tmp.path().join("real");
+            tokio::fs::create_dir(&real).await.unwrap();
+            let target = real.join(linked);
+            tokio::fs::rename(tmp.path().join(linked), &target)
+                .await
+                .unwrap();
+            std::os::unix::fs::symlink(&target, tmp.path().join(linked)).unwrap();
+            let target_before = tokio::fs::read(&target).await.unwrap();
+            let other = if linked == "pyproject.toml" {
+                "uv.lock"
+            } else {
+                "pyproject.toml"
+            };
+            let other_before = tokio::fs::read(tmp.path().join(other)).await.unwrap();
+
+            let p = load_uv_project(tmp.path()).await.unwrap();
+            let (code, detail) = wire_uv(
+                &p,
+                tmp.path(),
+                "six",
+                "1.16.0",
+                REL_WHEEL,
+                WHEEL_NAME,
+                WHEEL_SHA,
+                UUID,
+            )
+            .await
+            .unwrap_err();
+            assert_eq!(code, "pypi_uv_symlink_unsupported", "{linked}: {detail}");
+            assert!(detail.contains(linked), "{linked}: {detail}");
+            let meta = tokio::fs::symlink_metadata(tmp.path().join(linked))
+                .await
+                .unwrap();
+            assert!(meta.file_type().is_symlink(), "{linked}: link replaced");
+            assert_eq!(
+                tokio::fs::read(&target).await.unwrap(),
+                target_before,
+                "{linked}: target rewritten through the link"
+            );
+            assert_eq!(
+                tokio::fs::read(tmp.path().join(other)).await.unwrap(),
+                other_before,
+                "{linked}: the sibling file must be untouched"
+            );
+            assert!(
+                !tmp.path().join(".socket").exists(),
+                "{linked}: no vendor dir may appear"
+            );
+
+            // Revert against a symlinked pair: keep the artifact, fail.
+            let entry = entry_for(
+                Vec::new(),
+                UvMeta {
+                    dep_class: "direct".into(),
+                    original_specifier: None,
+                    created_sources_table: true,
+                    lock_revision: Some(3),
+                },
+            );
+            let outcome = revert_uv(&entry, tmp.path(), false).await;
+            assert!(!outcome.success, "{linked}: revert must fail");
+            assert!(outcome.kept_artifact, "{linked}: artifact must be kept");
+            let error = outcome.error.unwrap_or_default();
+            assert!(
+                error.contains("pypi_uv_symlink_unsupported") && error.contains(linked),
+                "{linked}: {error}"
+            );
+            let meta = tokio::fs::symlink_metadata(tmp.path().join(linked))
+                .await
+                .unwrap();
+            assert!(meta.file_type().is_symlink(), "{linked}: link replaced by revert");
+            assert_eq!(tokio::fs::read(&target).await.unwrap(), target_before);
+        }
+    }
 }
diff --git a/crates/socket-patch-core/src/vendor/toml_surgery.rs b/crates/socket-patch-core/src/vendor/toml_surgery.rs
index ae3af926..4837a61b 100644
--- a/crates/socket-patch-core/src/vendor/toml_surgery.rs
+++ b/crates/socket-patch-core/src/vendor/toml_surgery.rs
@@ -504,9 +504,11 @@ mod tests {
     #[test]
     fn removal_helpers_preserve_foreign_line_endings() {
         // pyproject.toml is user-authored: git autocrlf on Windows makes it
-        // CRLF, and the wire's toml_edit inserts append LF lines, so revert
-        // sees mixed endings. Every byte outside the removed segment must
-        // survive verbatim (the go_mod/go_sum CRLF-churn class).
+        // CRLF. The uv wire now renders its inserts in the file's own
+        // convention, but an older wire (or a hand edit) can still leave a
+        // mixed-ending file, so the removal helpers must never normalize:
+        // every byte outside the removed segment survives verbatim (the
+        // go_mod/go_sum CRLF-churn class).
         let wired = "[project]\r\nname = \"x\"\r\n\n[tool.uv.sources]\nfoo = { path = \"w.whl\" }\n";
         let after = remove_exact_line(wired, "foo = { path = \"w.whl\" }").unwrap();
         assert_eq!(after, "[project]\r\nname = \"x\"\r\n\n[tool.uv.sources]\n");
diff --git a/docs/ecosystems.md b/docs/ecosystems.md
index eb1ea778..a6673632 100644
--- a/docs/ecosystems.md
+++ b/docs/ecosystems.md
@@ -15,7 +15,7 @@ The backticked slug in each row is the value `-e`/`--ecosystems` accepts (e.g.
 | Ecosystem | agent (`--mode agent`) | vendored (`--mode vendored`) | hosted (`--mode hosted`) |
 |-----------|------------------------|------------------------------|--------------------------|
 | npm (`npm`) — pnpm / yarn / berry / bun | ✅ any install layout; `setup` postinstall hook | ✅ six lockfile flavors: package-lock, yarn classic, yarn berry (node-modules linker; PnP refused), pnpm v9, pnpm legacy v5.4/v6.0 (`pnpm 7/8` — frozen installs are path-bound because those majors absolutize `file:` override specifiers; moved checkouts run one `pnpm install --offline --no-frozen-lockfile`, surfaced as `vendor_pnpm_legacy_absolute_specifier`), bun `bun.lock` (binary `bun.lockb` refused with a `--save-text-lockfile` pointer). Rush monorepos refused (`vendor_rush_unsupported`) — see [Rush notes](#npm-rush-monorepos) | ✅ package-lock / npm-shrinkwrap, pnpm-lock.yaml (pnpm v5.4/v6.0/v9 — every major since pnpm 7), yarn classic, yarn berry, bun — pnpm, berry, and bun carry constraints, see [npm hosted-mode notes](#npm-hosted-mode-notes) |
-| PyPI (`pypi`) — uv / poetry / pdm / pipenv / pip | ✅ `.pth` startup hook via `setup` | ✅ uv project/script locks, PEP 751 `pylock.toml` / `pylock.<name>.toml`, poetry, pdm, pipenv (lock rewired, but pipenv doesn't hash-check file entries — `vendor_integrity_unverified` warning; the committed wheel bytes are the protection), and requirements.txt. Native uv vendoring requires uv ≥ 0.2; see [uv compatibility](testing/uv-compatibility.md). | ✅ requirements.txt including hash continuations, uv project/script locks, and PEP 751 locks. Version/source ambiguity is refused; see [uv compatibility](testing/uv-compatibility.md). **poetry / pdm / pipenv locks are not rewritten** — use vendored |
+| PyPI (`pypi`) — uv / poetry / pdm / pipenv / pip | ✅ `.pth` startup hook via `setup` | ✅ uv project/script locks, PEP 751 `pylock.toml` / `pylock.<name>.toml`, poetry, pdm, pipenv (lock rewired, but pipenv doesn't hash-check file entries — `vendor_integrity_unverified` warning; the committed wheel bytes are the protection), and requirements.txt. Native uv vendoring requires uv ≥ 0.2.35 (the `[[package]]` lock grammar); hosted mode covers native `uv.lock` from uv 0.1.45 (the first release whose `uv lock` writes one) and requirements from uv 0.0.5; see [uv compatibility](testing/uv-compatibility.md). | ✅ requirements.txt including hash continuations, uv project/script locks, and PEP 751 locks. Version/source ambiguity is refused; see [uv compatibility](testing/uv-compatibility.md). **poetry / pdm / pipenv locks are not rewritten** — use vendored |
 | Cargo (`cargo`) | ✅ in-place + `.cargo-checksum.json` rewrite (shared registry-cache caveat — see [Cargo: shared registry cache](#cargo-shared-registry-cache)) | ✅ `[patch.crates-io]` path entry | ✅ per-patch sparse registry (`[registries.socket-patch-<uuid>]` + Cargo.lock source/checksum) |
 | RubyGems (`gem`) | ✅ Bundler plugin via `setup` — needs bundler ≥ 2.2 (1.x cannot load `plugin ... path:` directives; `setup` refuses below the floor and `setup --check` red-flags a wired 1.x project) | ✅ Gemfile + Gemfile.lock path pair (`Gemfile` spelling only — a `gems.rb` project cannot vendor yet) | ✅ per-dep `source` block — edits `gems.rb` + `gems.locked` when present (bundler prefers them over `Gemfile`; spellings that diverge beyond Socket's own edits fail closed with `redirect_gem_gemfile_spellings_diverge`); the `CHECKSUMS` pin needs bundler ≥ 2.6 (older locks get a `redirect_gem_no_checksums_section` warning); a stale pre-redirect materialization that `bundle install` would reuse instead of refetching is flagged `redirect_gem_stale_install` with a prescriptive remedy (see CLI_CONTRACT.md's "Gem stale-install guard") |
 | Go (`golang`) | ✅ `go.mod` `replace` → `.socket/go-patches/` — see [Go: directory replaces and go.sum](#go-directory-replaces-and-gosum) | ✅ `replace` → the committed vendor tree | ✅ (free tier) fork-style `replace` → `patch.socket.dev/gopatch/<uuid>` + committed `go.sum` pin; see [golang-hosted.md](design/golang-hosted.md). Paid tier stays ❌ ([golang-hosted-no-go.md](design/golang-hosted-no-go.md)); `redirect_golang_unsupported` names the vendored remedy |
diff --git a/docs/testing/uv-compatibility.md b/docs/testing/uv-compatibility.md
index d8991ef9..d62b9ade 100644
--- a/docs/testing/uv-compatibility.md
+++ b/docs/testing/uv-compatibility.md
@@ -17,7 +17,7 @@ managers.
 |-------|--------|----------|
 | `requirements.txt`, including uv-generated hash continuations | Exact version pins become direct artifact URLs with the patched SHA-256. Extras and markers are retained; hashes for the replaced artifact are removed. | Requirements refer to a committed wheel under `.socket/vendor/pypi/` with its hash. |
 | `uv.lock`, native `version = 1`, `[[package]]` | The package source and artifact entry agree on the hosted URL and hash. A paired `pyproject.toml` receives the corresponding uv source configuration. | The package source refers to the committed wheel. The paired `pyproject.toml` records that source. |
-| `uv.lock`, experimental uv 0.1 `[[distribution]]` | Uses the legacy direct-source and artifact grammar, including source-qualified dependency references. | Refused: this grammar needs absolute file URLs, which cannot provide portable vendoring. Use uv 0.2 or newer. |
+| `uv.lock`, experimental `[[distribution]]` (uv 0.1.45–0.2.34) | Follows the entry's own shape: `direct+` string or `{ url = … }` table source, `[[distribution.wheel]]` sub-table or inline `wheels` entry, and source-qualified dependency references where the lock carries them. | Refused (`pypi_uv_legacy_lock_unsupported`): the experimental grammar cannot carry a portable local wheel — through 0.2.6 a relative path source does not parse, and on 0.2.17–0.2.34 `--locked` rejects it while `uv lock` and plain `uv sync` absolutize it. Use uv 0.2.35 or newer. |
 | `*.py.lock` with its PEP 723 `*.py` script | Rewrites the lock and the script's uv source metadata together. | Rewrites the lock and script metadata together and commits the patched wheel. |
 | `pylock.toml` and `pylock.<name>.toml`, PEP 751 `lock-version = "1.0"` | Uses one `archive` URL with the patched SHA-256. | Uses one `archive` path with the committed wheel's SHA-256. |
 
@@ -33,12 +33,93 @@ frozen, locked, and ordinary installation outcomes separately where supported.
 ## Limits
 
 - uv 0.0 has no native `uv.lock`; its compatibility lane is compiled requirements.
-  uv 0.0.5 rejects the bare local wheel paths emitted by vendored requirements;
-  use hosted mode or upgrade uv. Vendored requirements passed from uv 0.1.45
-  onward in this matrix.
+  `uv pip sync` rejects the bare local wheel paths emitted by vendored
+  requirements through uv 0.1.23 (`Unexpected '.', expected '-c', '-e', '-r'
+  or the start of a requirement`) and accepts them from 0.1.24; use hosted mode
+  or upgrade uv for older binaries.
+- `uv lock` itself has a boundary: the subcommand appears in 0.1.42 but panics
+  (`not yet implemented`) through 0.1.44 and first writes a lock at 0.1.45,
+  the last 0.1 release. Below that, hosted mode covers uv through compiled
+  requirements (from 0.0.5).
+- uv 0.1.45–0.2.34 write the experimental `[[distribution]]` lock
+  grammar; `[[package]]` starts at 0.2.35. The grammar went through three
+  shapes, and the hosted rewriter follows the entry's own shape on each axis:
+  string sources with sub-table artifacts (`source = "registry+…"`,
+  `[distribution.sdist]`, `[[distribution.wheel]]`, source-qualified
+  `[[distribution.dependencies]]`) through 0.2.5; string sources with inline
+  artifacts (`sdist = { … }`, `wheels = [ … ]`) from 0.2.6 through 0.2.17; and
+  inline-table sources (`source = { registry = … }`) from 0.2.18. Emitting the
+  wrong shape is not a parse error the user sees: 0.2.18–0.2.34 reject the
+  string source and silently ignore the lock (`--frozen` / `--locked` fail,
+  an ordinary `uv sync` still installs the patch via the pyproject source),
+  and 0.2.6–0.2.17 ignore an unexpected `[[distribution.wheel]]` and try to
+  build the direct wheel URL as a source archive. The `[[distribution]]`
+  grammar is hosted-only: vendored native wiring is refused with
+  `pypi_uv_legacy_lock_unsupported`. The refusal is kept because no spelling of
+  a committed wheel is stable across that era: through 0.2.6 a relative path
+  source cannot be parsed at all (`path+<rel>` is an invalid URL, `path+file:`
+  forms resolve against the filesystem root or panic); 0.2.17–0.2.34 install a
+  relative `{ path = … }` source under `--frozen` and plain `uv sync`, but
+  `--locked` rejects the non-canonical spelling, `uv lock` and plain `uv sync`
+  rewrite the path to an absolute one, resolution is relative to the current
+  directory rather than the project, and hashes are not verified before
+  0.2.34. Use uv 0.2.35 or newer for native vendoring; vendored requirements
+  work on the same binaries.
+- Vendored native wiring covers every `[[package]]`-grammar release, uv 0.2.35
+  onward. uv 0.2.35 and 0.2.36 wrote no root `[package.metadata]` yet (it
+  arrived in 0.2.37); on those locks the requires-dist repoint is skipped
+  rather than refused, and the package source plus the pyproject
+  `[tool.uv.sources]` entry carry the redirect (verified with `--frozen`,
+  `--locked`, and ordinary installs). A lock that has metadata but no entry
+  for the package is stale and is still refused with
+  `pypi_uv_lock_package_missing`.
 - Native lock versions other than `version = 1`, and PEP 751 versions other than
-  `lock-version = "1.0"`, are refused. Native lock revisions and command
-  availability are measured separately by the matrix below.
+  `lock-version = "1.0"`, are refused. Lock `revision` values 1 (0.6.0–0.6.14),
+  2 (0.6.15–0.8.3) and 3 (0.8.4 onward) are all covered by the matrix below.
+- Command availability boundaries observed with real binaries: `uv lock`
+  writes a lock from 0.1.45 (see above); `uv export` from 0.4.1, its
+  `--output-file` flag from 0.4.7 (the harness reads the export from stdout
+  below that); `uv lock --script` from 0.5.17; PEP 751 `uv pip compile
+  --output-file pylock.toml` from 0.6.15. Earlier binaries record those lanes
+  as unavailable, not as failures.
+- `[tool.uv] dev-dependencies` (the pre-PEP 735 dev group) is classified as a
+  direct dependency, and every duplicate `requires-dist` / `requires-dev`
+  entry for the package (extras, markers) is repointed, so `uv sync --locked`
+  accepts the lock. `[tool.uv] constraint-dependencies` /
+  `build-constraint-dependencies` naming the package are repointed in the
+  lock's `[manifest]` `constraints` / `build-constraints` entries, which uv
+  ≥ 0.5.6 serializes with the package's source. uv 0.2.37–0.5.3 serialize
+  constraints as `{ name, specifier }` regardless of sources, so on those
+  releases the repointed entry makes `uv sync --locked` fail (`--frozen` and
+  a plain `uv sync` still install the patch; the plain sync rewrites the
+  entry back). The CLI cannot tell those binaries apart from the lock, so the
+  repoint emits the advisory `pypi_uv_constraints_require_uv_0_5_6`. The
+  project-variant lane below exercises both shapes.
+- Transitive targets are wired through `[tool.uv] override-dependencies` plus
+  a `[tool.uv.sources]` entry. uv applies sources to overrides only from
+  0.5.6: on 0.2.35–0.5.3 `--frozen` installs the patched wheel from the lock,
+  but a plain `uv sync` re-resolves the override against the registry and
+  reinstalls the pristine wheel (and rewrites the lock). The CLI cannot tell
+  those binaries apart from the lock, so the override branch emits the
+  advisory warning `pypi_uv_override_requires_uv_0_5_6` instead of refusing.
+- Symlinked `uv.lock`, `pyproject.toml`, `pylock*.toml`, `*.py.lock` and
+  script files are discovered for inventory and `repair`, but every writer
+  refuses before touching anything — hosted
+  `redirect_symlinked_file_unsupported`, vendored `pypi_uv_symlink_unsupported`
+  / `pypi_lock_symlink_unsupported` — because uv writes through the link
+  while socket-patch's atomic stage-and-rename would replace the link with a
+  regular file, leaving the target unpatched and the checkout with a type
+  change. A symlink that is not one of the files to be written does not block
+  vendoring its regular siblings.
+- Vendored requirements install on uv ≥ 0.1.24 (the bare `./wheel` path
+  grammar). The `--hash` on that line is enforced only by `uv pip sync
+  --require-hashes`, which exists from 0.1.32, and by default from 0.5.x;
+  through 0.1.29 uv silently ignores hashes. uv ≤ 0.1.23 has no local path
+  grammar at all — hosted requirements work there.
+- Both uv backends preserve CRLF line endings: the hosted rewriter and the
+  vendored `uv.lock` / `pyproject.toml` writer (including the appended
+  `[manifest]` and `[package.metadata]` fragments and their revert) keep the
+  file's convention.
 - A script lock requires its paired script and a valid PEP 723 metadata block.
   Missing metadata or an incompatible existing source is reported before either
   file is rewritten.
@@ -53,13 +134,28 @@ frozen, locked, and ordinary installation outcomes separately where supported.
   pins, opaque URLs, and ambiguous unpinned rows are reported as
   `redirect_requirements_version_ambiguous` and preserved.
 - A script lock does not replace the main project's lockfile selection merely
-  by sharing its directory. An unrelated script lock does not block vendoring
-  a package from the project's requirements or Poetry lock. When multiple
+  by sharing its directory: its packages supplement the `poetry.lock` or
+  `requirements.txt` inventory rather than hiding it, and an unrelated script
+  lock does not block vendoring a package from the project's requirements or
+  Poetry lock. `uv.lock` keeps its exclusive precedence. When multiple
   applicable package-manager locks coexist, the CLI reports its precedence
   choice and the locks it leaves unchanged.
-- Vendored installation needs the committed artifact tree. Older uv versions
-  can also require build dependencies for the root project; an unavailable
-  offline build dependency is distinct from failure to install the patched wheel.
+- Vendored installation needs the committed artifact tree. uv 0.2.35–0.3.5
+  cannot build the ROOT fixture from an empty cache under `--offline`
+  (`setuptools>=40.8.0` is a build dependency of the fixture, not of the
+  patched wheel). `uv sync --no-install-project` exists from 0.3.3 and the
+  harness passes it whenever `sync --help` lists it, which is why the 0.3.5
+  row passes cold; from 0.4.0 uv no longer builds a root without a
+  `[build-system]`, so ≥ 0.4.0 passes regardless; ≤ 0.2.34 vendoring is
+  refused, so the case is never exercised there. On 0.2.35–0.3.0 the harness
+  retries the install with network access and records it as
+  `project-vendored-frozen-sync-root-build-networked`, distinct from any
+  failure to install the patched wheel.
+- `vendor --revert` refuses to delete a vendored Python wheel while `uv.lock`,
+  a PEP 751 lock, a script, or `requirements.txt` still references it and the
+  ledger entry has no wiring to replay (the shape `socket-patch repair`
+  rebuilds when `state.json` is lost); `vendor_wiring_unknown_revert_blocked`
+  names the file. Restore the pre-vendor files (or re-lock) first.
 
 Revert state retains the original wiring. Script and lock edits are treated as a
 pair: conflicting changes preserve both files and their recovery state rather
@@ -68,28 +164,47 @@ preserving another package's vendored entries.
 
 ## Reproduce the release-family matrix
 
-The matrix pins these 14 binaries: `0.0.5`, `0.1.45`, `0.2.37`, `0.3.5`,
-`0.4.30`, `0.5.31`, `0.6.0`, `0.6.17`, `0.7.22`, `0.8.24`, `0.9.30`,
-`0.10.12`, `0.11.33`, and `0.12.13`. They cover uv 0.0 through 0.12 and the
-additional 0.6 lock-revision boundary. This is release-family coverage, not a
-claim that every patch release was tested.
+The matrix pins 42 binaries: the first and the latest release of every uv 0.x
+family (0.0 through 0.12), plus the releases on either side of every behaviour
+boundary the probes found — `0.1.23`/`0.1.24` (local wheel paths in
+requirements), `0.1.44`/`0.1.45` (`uv lock` writes a lock; the subcommand
+exists from 0.1.42 and panics `not yet implemented` through 0.1.44),
+`0.2.5`/`0.2.6` (sub-table → inline lock artifacts),
+`0.2.17`/`0.2.18` (string → inline-table lock sources),
+`0.2.34`/`0.2.35` (`[[distribution]]` → `[[package]]`), `0.2.36`/`0.2.37`
+(root `[package.metadata]` appears),
+`0.4.0`/`0.4.1` (`uv export`), `0.5.16`/`0.5.17` (`uv lock --script`),
+`0.6.14`/`0.6.15` (PEP 751 export; lock revision 2) and `0.8.3`/`0.8.4` (lock
+revision 3). The full list is `VERSIONS` in `scripts/backtest-uv.py`; the
+boundaries were bisected with `scripts/probe-uv-boundaries.py`, which records
+the lock grammar, lock revision, command availability (including whether the
+`uv lock` subcommand exists and actually writes a lock, and whether `uv export`
+accepts `--output-file`), and local-wheel requirement support of any set of uv
+releases. The one probe-pinned boundary the matrix does not bracket is the
+`uv export --output-file` flag (0.4.6/0.4.7): the harness reads the export
+from stdout, so it is a harness detail rather than a compatibility boundary.
+This is release-family plus boundary coverage, not a claim that every patch
+release was tested.
 
 From the repository root on macOS or Linux:
 
 ```sh
 cargo build -p socket-patch-cli
+cp target/debug/socket-patch /tmp/socket-patch-backtest-bin
 python3 scripts/backtest-uv.py \
-  --socket-patch target/debug/socket-patch \
+  --socket-patch /tmp/socket-patch-backtest-bin \
   --socket-patch-revision "$(git rev-parse HEAD)" \
   --python /path/to/python3 \
   --output /tmp/socket-patch-uv-backtest
 ```
 
 Use Python 3.9 to match the recorded probes; the fixtures declare it as their
-minimum.
-`--versions` can select a smaller diagnostic run. The script downloads pinned uv
-binaries and the pristine urllib3 wheel from PyPI and verifies their registry
-hashes. It runs against the public patch proxy without an API token.
+minimum. Copy the CLI out of `target/` first so a rebuild cannot swap the binary
+under a running matrix. The default list takes roughly half an hour with the
+harness's four workers; `--versions` selects a smaller diagnostic run. The
+script downloads pinned uv binaries and the pristine urllib3 wheel from PyPI and
+verifies their registry hashes. It runs against the public patch proxy without
+an API token.
 
 For each binary, the run records command lines, exit codes, output, artifact
 hashes, and installed `urllib3/response.py` hashes. It exercises native locks,
@@ -99,6 +214,41 @@ Unsupported commands remain visible in the results; they are not counted as
 successful installation tests. A successful CLI exit with a refusal warning is
 also not counted as a successful rewrite.
 
+On every `[[package]]`-grammar binary (uv ≥ 0.2.35) the run adds a
+project-variant lane (`variant_matrix` in the script, `variant-<name>-<mode>-*`
+cases in `results.json`). Five pyproject shapes are locked fresh, scanned in
+hosted and vendored mode, and installed from the patched lock into a fresh
+environment with `uv sync --frozen`, `uv sync --locked` (where the binary has
+it) and a plain `uv sync`, recording the exit code, whether the lock survived
+untouched, and the installed bytes:
+
+- `tool-uv-dev` — `dependencies = []` plus `[tool.uv] dev-dependencies`;
+- `dependency-groups` — `dependencies = []` plus PEP 735 `[dependency-groups]`
+  `dev` (honoured from uv 0.4.27; older binaries lock an empty project and the
+  row records `formatSupported: false`);
+- `extras-duplicate` — the package both in `dependencies` and in
+  `[project.optional-dependencies]`, so the lock carries two `requires-dist`
+  entries for it;
+- `constraints` — the package in `dependencies` plus `[tool.uv]
+  constraint-dependencies`, giving the lock a `[manifest]` constraints entry
+  (skipped as unsupported when the binary records none);
+- `transitive` — `requests==2.28.2` with `[tool.uv] exclude-newer =
+  "2024-01-01T00:00:00Z"` so urllib3 resolves to 1.26.18 as a transitive
+  dependency; the CLI takes the override-dependencies branch, and on uv
+  < 0.5.6 the plain `uv sync` row is expected to reinstall the pristine wheel
+  (recorded as `installedPatch: false`, see Limits).
+
+A plain `uv sync` that rewrites the lock is recorded (`lockUnchanged: false`),
+not raised: it is a real observation, not a harness error. No export or PEP 751
+lanes run for the variants. Each version row in `results.json` carries a
+`variants` summary; the tables below are printed from that file with
+`--render-doc-table` (see the markers in the results section), so the doc can be
+regenerated after a full run without hand-editing:
+
+```sh
+python3 scripts/backtest-uv.py --render-doc-table /tmp/socket-patch-uv-backtest/results.json
+```
+
 Keep live download grants out of committed evidence. Published patch UUIDs,
 archive filenames, hashes, uv versions, and redacted command results are enough
 to identify a run. Compare the fresh installed bytes with the patched artifact,
@@ -106,21 +256,29 @@ not just with a URL or a success message.
 
 ## Full matrix results
 
-The complete run finished on **2026-09-14**, using macOS **26.6.2 arm64** and
-Python **3.9.6**. It tested socket-patch source commit
-`e11bd419ea9c01b3ecd1aa894b55874718a3ff0a` (`socket-patch 4.0.0`), with binary
-SHA-256:
+<!-- GENERATED:BEGIN — everything down to GENERATED:END is printed by
+     `python3 scripts/backtest-uv.py --render-doc-table <output>/results.json`;
+     regenerate it after a matrix run instead of editing by hand. -->
+The complete run finished on **2026-09-15**, using
+**macOS-26.6.2-arm64-arm-64bit-Mach-O** and Python **3.9.6**. It tested
+socket-patch source commit `17d0dcb84bab1bec030117e0f111c7bfd893c2eb`
+(`socket-patch 4.0.0`), with binary SHA-256:
 
 ```text
-eb5f6695a06c2124ac5c09f2117bf42e8777d767aec09c1de6ee16cd9dc4adee
+be7a0e3dd86d540b0dc038437410bec6042bcaad5ae8beba92fae23015b56548
 ```
 
-All **230 installed-byte comparisons passed**, with zero mismatches. All **99
-recorded lock-preservation checks passed**. This includes frozen and locked
-installs where supported; ordinary installs also delivered the patched bytes.
-The [machine-readable results](uv-compatibility/results.json) contain all 495
-observations and their command definitions. The [binary catalog](uv-compatibility/binaries.json)
-records each uv wheel's public PyPI source and verified hash.
+**1403 installed-byte comparisons** ran, with **18 mismatches**. **1086
+lock-preservation checks** were recorded — every install attempt against a
+patched lock (`--frozen` and `--locked` where the binary provides them, plain
+`uv sync` where it does not, `uv run --frozen --script`, `uv pip sync
+pylock.toml`, and the project-variant installs), including failed installs whose
+lock was left untouched — and **32 changed the lock**. `--frozen` never writes
+the lock, so the 383 `--locked` rows are the ones that measure preservation; 351
+of them exited 0. The [machine-readable results](uv-compatibility/results.json)
+contain all 2769 observations and their command definitions. The [binary
+catalog](uv-compatibility/binaries.json) records each uv wheel's public PyPI
+source and verified hash.
 
 Each paired result below is **hosted / vendored**. “Pass” means the installed
 `urllib3/response.py` matched the published patch; “—” means that uv binary did
@@ -130,35 +288,137 @@ compilation. PEP 751 covers both standalone locks and exported locks.
 | uv | Native grammar | Native H/V | Requirements H/V | Requirements export H/V | Scripts H/V | PEP 751 H/V | Verified installs |
 |----|----------------|------------|------------------|-------------------------|-------------|-------------|-------------------|
 | 0.0.5 | No native lock | — / — | Pass / rejected path | — / — | — / — | — / — | 2 |
+| 0.1.0 | No native lock | — / — | Pass / rejected path | — / — | — / — | — / — | 2 |
+| 0.1.23 | No native lock | — / — | Pass / rejected path | — / — | — / — | — / — | 2 |
+| 0.1.24 | No native lock | — / — | Pass / Pass | — / — | — / — | — / — | 4 |
+| 0.1.44 | No native lock | — / — | Pass / Pass | — / — | — / — | — / — | 4 |
 | 0.1.45 | `distribution`, v1 | Pass / refused | Pass / Pass | — / — | — / — | — / — | 6 |
-| 0.2.37 | `package`, v1 | Pass / Pass¹ | Pass / Pass | — / — | — / — | — / — | 10 |
-| 0.3.5 | `package`, v1 | Pass / Pass | Pass / Pass | — / — | — / — | — / — | 10 |
-| 0.4.30 | `package`, v1 | Pass / Pass | Pass / Pass | Pass / Pass | — / — | — / — | 12 |
-| 0.5.31 | `package`, v1 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | — / — | 18 |
-| 0.6.0 | `package`, v1 r1 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | — / — | 18 |
-| 0.6.17 | `package`, v1 r2 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 22 |
-| 0.7.22 | `package`, v1 r2 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 22 |
-| 0.8.24 | `package`, v1 r3 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 22 |
-| 0.9.30 | `package`, v1 r3 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 22 |
-| 0.10.12 | `package`, v1 r3 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 22 |
-| 0.11.33 | `package`, v1 r3 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 22 |
-| 0.12.13 | `package`, v1 r3 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 22 |
-
-The nonzero outcomes were the documented boundaries:
-
-- uv 0.0.5 rejected vendored requirements' local wheel path syntax, although
-  both hosted requirements variants installed the patch.
-- Native vendoring on uv 0.1.45 was refused with
-  `pypi_uv_legacy_lock_unsupported`; hosted native installs and both requirements
-  modes installed the patch.
-- ¹ uv 0.2.37's cold offline native install could not build the root fixture
-  because `setuptools>=40.8.0` was absent from its empty cache. The network-enabled
-  retry installed the patched wheel. Its subsequent locked and ordinary
-  installation checks also passed.
+| 0.2.0 | `distribution`, v1 | Pass / refused | Pass / Pass | — / — | — / — | — / — | 6 |
+| 0.2.5 | `distribution`, v1 | Pass / refused | Pass / Pass | — / — | — / — | — / — | 6 |
+| 0.2.6 | `distribution`, v1 | Pass / refused | Pass / Pass | — / — | — / — | — / — | 6 |
+| 0.2.17 | `distribution`, v1 | Pass / refused | Pass / Pass | — / — | — / — | — / — | 6 |
+| 0.2.18 | `distribution`, v1 | Pass / refused | Pass / Pass | — / — | — / — | — / — | 6 |
+| 0.2.34 | `distribution`, v1 | Pass / refused | Pass / Pass | — / — | — / — | — / — | 7 |
+| 0.2.35 | `package`, v1 | Pass / Pass¹ | Pass / Pass | — / — | — / — | — / — | 24 |
+| 0.2.36 | `package`, v1 | Pass / Pass¹ | Pass / Pass | — / — | — / — | — / — | 24 |
+| 0.2.37 | `package`, v1 | Pass / Pass¹ | Pass / Pass | — / — | — / — | — / — | 28 |
+| 0.3.0 | `package`, v1 | Pass / Pass¹ | Pass / Pass | — / — | — / — | — / — | 28 |
+| 0.3.5 | `package`, v1 | Pass / Pass | Pass / Pass | — / — | — / — | — / — | 28 |
+| 0.4.0 | `package`, v1 | Pass / Pass | Pass / Pass | — / — | — / — | — / — | 28 |
+| 0.4.1 | `package`, v1 | Pass / Pass | Pass / Pass | Pass / Pass | — / — | — / — | 30 |
+| 0.4.30 | `package`, v1 | Pass / Pass | Pass / Pass | Pass / Pass | — / — | — / — | 36 |
+| 0.5.0 | `package`, v1 | Pass / Pass | Pass / Pass | Pass / Pass | — / — | — / — | 36 |
+| 0.5.16 | `package`, v1 | Pass / Pass | Pass / Pass | Pass / Pass | — / — | — / — | 42 |
+| 0.5.17 | `package`, v1 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | — / — | 48 |
+| 0.5.31 | `package`, v1 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | — / — | 48 |
+| 0.6.0 | `package`, v1 r1 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | — / — | 48 |
+| 0.6.14 | `package`, v1 r1 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | — / — | 48 |
+| 0.6.15 | `package`, v1 r2 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 52 |
+| 0.6.17 | `package`, v1 r2 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 52 |
+| 0.7.0 | `package`, v1 r2 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 52 |
+| 0.7.22 | `package`, v1 r2 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 52 |
+| 0.8.0 | `package`, v1 r2 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 52 |
+| 0.8.3 | `package`, v1 r2 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 52 |
+| 0.8.4 | `package`, v1 r3 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 52 |
+| 0.8.24 | `package`, v1 r3 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 52 |
+| 0.9.0 | `package`, v1 r3 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 52 |
+| 0.9.30 | `package`, v1 r3 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 52 |
+| 0.10.0 | `package`, v1 r3 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 52 |
+| 0.10.12 | `package`, v1 r3 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 52 |
+| 0.11.0 | `package`, v1 r3 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 52 |
+| 0.11.33 | `package`, v1 r3 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 52 |
+| 0.12.0 | `package`, v1 r3 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 52 |
+| 0.12.15 | `package`, v1 r3 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | 52 |
+
+### Project variants (uv ≥ 0.2.35)
+
+Each `[[package]]`-grammar binary also locks five further project shapes
+(`variant-*` cases in the results), scans them in both modes, and installs from
+the patched lock with `--frozen`, `--locked` (where available) and a plain `uv
+sync`, each into a fresh environment. “Pass” requires the patched bytes from
+every executed install and an untouched lock after `--locked`; “Fail: …” names
+the installs that missed; “refused” means the CLI reported the shape unsupported
+and left the lock unpatched; “—” means the binary cannot lock that shape (no
+`[dependency-groups]`, no `[manifest]` constraints, or no `exclude-newer`
+setting).
+
+| uv | tool-uv-dev H/V | dependency-groups H/V | extras-duplicate H/V | constraints H/V | transitive H/V |
+|----|-----------------|-----------------------|----------------------|-----------------|----------------|
+| 0.2.35 | Pass / Pass | — / — | Pass / Pass | — / — | Fail: locked, plain / Fail: locked, plain |
+| 0.2.36 | Pass / Pass | — / — | Pass / Pass | — / — | Fail: locked, plain / Fail: locked, plain |
+| 0.2.37 | Pass / Pass | — / — | Pass / Pass | Fail: locked / Fail: locked | Fail: locked, plain / Fail: locked, plain |
+| 0.3.0 | Pass / Pass | — / — | Pass / Pass | Fail: locked / Fail: locked | Fail: locked, plain / Fail: locked, plain |
+| 0.3.5 | Pass / Pass | — / — | Pass / Pass | Fail: locked / Fail: locked | Fail: locked, plain / Fail: locked, plain |
+| 0.4.0 | Pass / Pass | — / — | Pass / Pass | Fail: locked / Fail: locked | Fail: locked, plain / Fail: locked, plain |
+| 0.4.1 | Pass / Pass | — / — | Pass / Pass | Fail: locked / Fail: locked | Fail: locked, plain / Fail: locked, plain |
+| 0.4.30 | Pass / Pass | Pass / Pass | Pass / Pass | Fail: locked / Fail: locked | Fail: locked, plain / Fail: locked, plain |
+| 0.5.0 | Pass / Pass | Pass / Pass | Pass / Pass | Fail: locked / Fail: locked | Fail: locked, plain / Fail: locked, plain |
+| 0.5.16 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass |
+| 0.5.17 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass |
+| 0.5.31 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass |
+| 0.6.0 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass |
+| 0.6.14 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass |
+| 0.6.15 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass |
+| 0.6.17 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass |
+| 0.7.0 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass |
+| 0.7.22 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass |
+| 0.8.0 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass |
+| 0.8.3 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass |
+| 0.8.4 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass |
+| 0.8.24 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass |
+| 0.9.0 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass |
+| 0.9.30 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass |
+| 0.10.0 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass |
+| 0.10.12 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass |
+| 0.11.0 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass |
+| 0.11.33 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass |
+| 0.12.0 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass |
+| 0.12.15 | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass | Pass / Pass |
+<!-- GENERATED:END -->
+
+Nonzero outcomes and mismatches in this run, and what each one is:
+
+- uv 0.0.5 through 0.1.23 rejected vendored requirements' local wheel path
+  syntax (`Unexpected '.', expected '-c', '-e', '-r' or the start of a
+  requirement`); 0.1.24 onward accepted it. Both hosted requirements variants
+  installed the patch on every binary. uv 0.0.5–0.1.44 have no working
+  `uv lock` (the `lock` rows exit 2), so their native lanes are `—`.
+- Native vendoring on every `[[distribution]]`-grammar binary (0.1.45 through
+  0.2.34) was refused with `pypi_uv_legacy_lock_unsupported`; hosted native
+  installs — in all three shapes: sub-table artifacts (through 0.2.5), inline
+  artifacts with string sources (0.2.6–0.2.17), and inline-table sources
+  (0.2.18–0.2.34) — and both requirements modes installed the patch.
+- ¹ uv 0.2.35, 0.2.36, 0.2.37 and 0.3.0 cannot build the root fixture from an
+  empty cache under `--offline` (`setuptools>=40.8.0` was absent). The
+  network-enabled retry (`project-vendored-frozen-sync-root-build-networked`)
+  installed the patched wheel; the subsequent locked and ordinary installation
+  checks also passed.
 - Export, script-lock, and PEP 751 commands unavailable in older binaries were
-  recorded as unavailable, not installation successes. Some older uv binaries
-  accepted an output filename ending in `pylock.toml` but emitted requirements
-  text; those results have `formatSupported: false`.
+  recorded as unavailable, not installation successes (`uv export` from 0.4.1,
+  `uv lock --script` from 0.5.17, PEP 751 compilation from 0.6.15 — 0.6.14
+  exits 2 on the `pylock.toml` output). Some older uv binaries accepted an
+  output filename ending in `pylock.toml` but emitted requirements text; those
+  results have `formatSupported: false`.
+- The **18 installed-byte mismatches** are all the `transitive` variant's plain
+  `uv sync` rows on 0.2.35–0.5.0 (nine binaries, both modes): those releases
+  do not apply `[tool.uv.sources]` to `override-dependencies`, so the plain
+  sync re-resolves the override against the registry and installs the pristine
+  wheel; `--frozen` installed the patch on every one of them. This is the
+  boundary the `pypi_uv_override_requires_uv_0_5_6` advisory names; from
+  0.5.16 (the first ≥ 0.5.6 binary in the matrix) every install passes.
+- The **32 lock changes** and the 32 non-zero `--locked` rows are those same
+  18 transitive rows plus the `constraints` variant's plain-sync / `--locked`
+  rows on 0.2.37–0.5.0 (seven binaries, both modes): those releases serialize
+  `[manifest] constraints` as `{ name, specifier }` regardless of sources, so
+  they reject the repointed entry under `--locked` and rewrite it back on a
+  plain sync — which still installed the patch (no mismatch). 0.2.35 and
+  0.2.36 do not record constraints in the lock (`—`). This is the boundary the
+  `pypi_uv_constraints_require_uv_0_5_6` advisory names; from 0.5.16 every
+  constraints install passes with the lock untouched.
+- Every other `--locked`, `--frozen`, plain, script and PEP 751 install
+  delivered the patched bytes with the lock byte-unchanged, including the
+  `[tool.uv] dev-dependencies`, `[dependency-groups]` and extras-duplicate
+  shapes on every binary that can lock them.
 
 ## Completed conditional-requirements and refusal checks
 
diff --git a/docs/testing/uv-compatibility/binaries.json b/docs/testing/uv-compatibility/binaries.json
index 5a97503d..58ebb0e7 100644
--- a/docs/testing/uv-compatibility/binaries.json
+++ b/docs/testing/uv-compatibility/binaries.json
@@ -6,6 +6,34 @@
     "uploaded": "2024-02-15T18:56:14.105999Z",
     "filename": "uv-0.0.5-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl"
   },
+  {
+    "version": "0.1.0",
+    "url": "https://files.pythonhosted.org/packages/0c/e3/415f40a86918316951b69b42661731bf6c5e5007f4063bc564773aec4815/uv-0.1.0-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl",
+    "sha256": "71291b3b3222da25a6af5ab9dfaec3bdd97fd4f0d21cf38a04cbd63000fa9da5",
+    "uploaded": "2024-02-15T19:44:47.783250Z",
+    "filename": "uv-0.1.0-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl"
+  },
+  {
+    "version": "0.1.23",
+    "url": "https://files.pythonhosted.org/packages/e4/02/824e40366ecd913483d67723aa10079b5d127b43d7f8c3f164dcf19fb9c4/uv-0.1.23-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl",
+    "sha256": "d9d1d6d2bca50b9ea2ed764a6931b53995f6b5dbf3def9eafbcec57a88b4a6e2",
+    "uploaded": "2024-03-21T03:09:59.075241Z",
+    "filename": "uv-0.1.23-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl"
+  },
+  {
+    "version": "0.1.24",
+    "url": "https://files.pythonhosted.org/packages/1e/ef/90fc17103183c23e8e5142c455b1ca8c1c38142c89c8aaa27f7ab37c34f5/uv-0.1.24-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl",
+    "sha256": "33d74c4c67df34de18c4318a6c568efef9dfab6d05332b1d1eddc8e516fc8806",
+    "uploaded": "2024-03-22T20:15:08.127518Z",
+    "filename": "uv-0.1.24-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl"
+  },
+  {
+    "version": "0.1.44",
+    "url": "https://files.pythonhosted.org/packages/85/6a/4e98521c359f593cdd8cebc6381c09be1d133bd93031e76accc6b8aa7788/uv-0.1.44-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "e247dca0d8d42d71032ac99ef3d72a4fcbad4ae3114ef5979878a81a40fed274",
+    "uploaded": "2024-05-14T14:28:43.548037Z",
+    "filename": "uv-0.1.44-py3-none-macosx_11_0_arm64.whl"
+  },
   {
     "version": "0.1.45",
     "url": "https://files.pythonhosted.org/packages/7f/15/46efcaa86ebef51b8663d8beb95c8376fbdaaf45aeffbc269bf0a3527092/uv-0.1.45-py3-none-macosx_11_0_arm64.whl",
@@ -13,6 +41,62 @@
     "uploaded": "2024-05-20T21:05:54.623510Z",
     "filename": "uv-0.1.45-py3-none-macosx_11_0_arm64.whl"
   },
+  {
+    "version": "0.2.0",
+    "url": "https://files.pythonhosted.org/packages/cc/4a/7c3d702c5920487d481bd03a3ca821f8886ad2d6937e49f4efc0a16c6e61/uv-0.2.0-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "ba5e339a0fb32a02142346eea4d46f6ad618a390df5d70515ba0e1d3c6f7ce41",
+    "uploaded": "2024-05-22T19:11:42.407716Z",
+    "filename": "uv-0.2.0-py3-none-macosx_11_0_arm64.whl"
+  },
+  {
+    "version": "0.2.5",
+    "url": "https://files.pythonhosted.org/packages/06/d2/ef1c65a0715731da623b430757a9b851167309fc7e326140d27d246e6541/uv-0.2.5-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "650f81439c4f65e86fdba84f2cbb6700a074b95d70c5cc3d38e8ce2b87e43a45",
+    "uploaded": "2024-05-28T18:33:49.720762Z",
+    "filename": "uv-0.2.5-py3-none-macosx_11_0_arm64.whl"
+  },
+  {
+    "version": "0.2.6",
+    "url": "https://files.pythonhosted.org/packages/a0/53/4c9a7370ec5bf75b89b82117fae68d7bb268d229deb82c51264ca27a1368/uv-0.2.6-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "1ac3b96c6284ef2e5367e62f31472cc3f27ba4c7e14f579e7c6dbd081943e38b",
+    "uploaded": "2024-06-03T18:22:26.325121Z",
+    "filename": "uv-0.2.6-py3-none-macosx_11_0_arm64.whl"
+  },
+  {
+    "version": "0.2.17",
+    "url": "https://files.pythonhosted.org/packages/90/c0/27b6fc7cc85984b0c86ffd0e42abf4c97aeff2cc3425b09ce86e679bedae/uv-0.2.17-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "d6628bcb0d21f2f8489ed33818fa6c2da3a472adead076864701ae7a3bafb4de",
+    "uploaded": "2024-06-26T23:39:17.070293Z",
+    "filename": "uv-0.2.17-py3-none-macosx_11_0_arm64.whl"
+  },
+  {
+    "version": "0.2.18",
+    "url": "https://files.pythonhosted.org/packages/60/0d/d462d188343464876ca196f064ba1682982446012c4893da0d7dbba01a8c/uv-0.2.18-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "eee9773a0a9f02d084a584279891df1fdf4de32d067f273b9480f86c9f91dcdb",
+    "uploaded": "2024-06-29T18:49:23.499620Z",
+    "filename": "uv-0.2.18-py3-none-macosx_11_0_arm64.whl"
+  },
+  {
+    "version": "0.2.34",
+    "url": "https://files.pythonhosted.org/packages/f2/a0/840b0fa6b9f884384b558b8690cad603bdc0da2b7a67cec2755b612839c9/uv-0.2.34-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "4ce15beeba44e4ea052d83c89eb4ea3586dfd68bab039c5cdf44b90fbfc5698d",
+    "uploaded": "2024-08-07T20:59:42.011904Z",
+    "filename": "uv-0.2.34-py3-none-macosx_11_0_arm64.whl"
+  },
+  {
+    "version": "0.2.35",
+    "url": "https://files.pythonhosted.org/packages/00/eb/c578ebb0f606be6a3a1c37e36a8b6068008ceab54db95a2ab70452c792fd/uv-0.2.35-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "3ff91eb85e0804d5f609f18a911b33d81b06e11c1bced1bf1396a2d738e97bc0",
+    "uploaded": "2024-08-10T00:42:30.944714Z",
+    "filename": "uv-0.2.35-py3-none-macosx_11_0_arm64.whl"
+  },
+  {
+    "version": "0.2.36",
+    "url": "https://files.pythonhosted.org/packages/80/40/e951bc5598dbd7d58a6daf33a93977ecbaad60fdaa584610349f00acf521/uv-0.2.36-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "8820dd5b77ffcda07dde09712a43d969d39b0aace112d8074c540f19a4911cc2",
+    "uploaded": "2024-08-13T17:28:27.711187Z",
+    "filename": "uv-0.2.36-py3-none-macosx_11_0_arm64.whl"
+  },
   {
     "version": "0.2.37",
     "url": "https://files.pythonhosted.org/packages/e6/84/2c973ddb320642d02d2d117123a61ec6666bbc0143f5263b1e0c791c1252/uv-0.2.37-py3-none-macosx_11_0_arm64.whl",
@@ -20,6 +104,13 @@
     "uploaded": "2024-08-16T02:45:56.044623Z",
     "filename": "uv-0.2.37-py3-none-macosx_11_0_arm64.whl"
   },
+  {
+    "version": "0.3.0",
+    "url": "https://files.pythonhosted.org/packages/61/95/b6603342b9a0a180776e7aec845079cdc66fb521157ed9bf62b4e4174983/uv-0.3.0-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "39a4276afe0808ca6c033e0cd6cb73249f934b4a0c9d7b18a944f3f8ea635e27",
+    "uploaded": "2024-08-20T17:52:38.258401Z",
+    "filename": "uv-0.3.0-py3-none-macosx_11_0_arm64.whl"
+  },
   {
     "version": "0.3.5",
     "url": "https://files.pythonhosted.org/packages/83/8e/956ad3788cfa863cc8de148907e371b025acd97f7a0bb2a9e78ce63c2b1e/uv-0.3.5-py3-none-macosx_11_0_arm64.whl",
@@ -27,6 +118,20 @@
     "uploaded": "2024-08-27T17:10:36.293543Z",
     "filename": "uv-0.3.5-py3-none-macosx_11_0_arm64.whl"
   },
+  {
+    "version": "0.4.0",
+    "url": "https://files.pythonhosted.org/packages/2e/86/9844e8ab08e25cbf2094e2fa1a7ad66563036bfed77b46986b6a2489c10c/uv-0.4.0-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "02e0295566454289348de502677e2240ad86f2cb5fa058504e1b2ca2a2ebf7e1",
+    "uploaded": "2024-08-28T18:00:42.051786Z",
+    "filename": "uv-0.4.0-py3-none-macosx_11_0_arm64.whl"
+  },
+  {
+    "version": "0.4.1",
+    "url": "https://files.pythonhosted.org/packages/46/ad/90e0d7a448b4c92846589c8bb92813ac45d2b123a2b9d4cab4167e805f9f/uv-0.4.1-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "fcdc6503100e86fecf6a727d3149e54581e8e9ad6c10e814fc5d22c1e80fab8d",
+    "uploaded": "2024-08-30T14:42:40.152858Z",
+    "filename": "uv-0.4.1-py3-none-macosx_11_0_arm64.whl"
+  },
   {
     "version": "0.4.30",
     "url": "https://files.pythonhosted.org/packages/67/37/8994c3d0be99851a21a6ee01bbf3cb35ddc4b202a2f6f4014098d5893660/uv-0.4.30-py3-none-macosx_11_0_arm64.whl",
@@ -34,6 +139,27 @@
     "uploaded": "2024-11-05T01:13:59.667063Z",
     "filename": "uv-0.4.30-py3-none-macosx_11_0_arm64.whl"
   },
+  {
+    "version": "0.5.0",
+    "url": "https://files.pythonhosted.org/packages/69/fb/e778bce57b12eac37c1e9e8e1efc8b190a2c72dee02b532d13706be447f4/uv-0.5.0-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "a3bc6911be7d86f3750bce1580e664877a3a88c126eb68afbb132cd0896fd109",
+    "uploaded": "2024-11-07T23:05:15.972013Z",
+    "filename": "uv-0.5.0-py3-none-macosx_11_0_arm64.whl"
+  },
+  {
+    "version": "0.5.16",
+    "url": "https://files.pythonhosted.org/packages/0f/c4/74f4507f48ce5e38cef46cecd7716af0348dffcb3d40245189422226c7b7/uv-0.5.16-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "3419888b178b82511faebd8d1ca9cb9f5920a7142406898d76878adaffe8dfb1",
+    "uploaded": "2025-01-08T16:40:50.904248Z",
+    "filename": "uv-0.5.16-py3-none-macosx_11_0_arm64.whl"
+  },
+  {
+    "version": "0.5.17",
+    "url": "https://files.pythonhosted.org/packages/f1/7e/4c8b7ca07945fe6ffd1a7e5d1f992b72534be69e97e20a2536d192734adc/uv-0.5.17-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "12789bf19457e3c5fc20767960203ab60222124afe2cbdfde92a657318651a64",
+    "uploaded": "2025-01-10T21:13:54.034599Z",
+    "filename": "uv-0.5.17-py3-none-macosx_11_0_arm64.whl"
+  },
   {
     "version": "0.5.31",
     "url": "https://files.pythonhosted.org/packages/1f/5a/1eb42f481a9f9010c8c194d70ab375a6eda96d67ca1fd011bf869d4016c8/uv-0.5.31-py3-none-macosx_11_0_arm64.whl",
@@ -48,6 +174,20 @@
     "uploaded": "2025-02-14T18:20:31.778738Z",
     "filename": "uv-0.6.0-py3-none-macosx_11_0_arm64.whl"
   },
+  {
+    "version": "0.6.14",
+    "url": "https://files.pythonhosted.org/packages/72/89/e7fc8a047f08234cc26d1e37e5f573887744205d087f8e8e6f3d0feb04ce/uv-0.6.14-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "9fc8fe58871b4fe02a863b05b8b1b25ef1b6c60d4d224e85338f5c2be0ab4f0e",
+    "uploaded": "2025-04-09T21:56:12.061201Z",
+    "filename": "uv-0.6.14-py3-none-macosx_11_0_arm64.whl"
+  },
+  {
+    "version": "0.6.15",
+    "url": "https://files.pythonhosted.org/packages/f6/88/ad35ecc3b986274ff560267cb6e3b9119ca0f8cc82c61e2acae28c8b9ffe/uv-0.6.15-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "f113d1746ce7fdffada6f9e12b2f667d2b9069a3c3d5b05b680836102f2586c1",
+    "uploaded": "2025-04-22T00:50:26.375142Z",
+    "filename": "uv-0.6.15-py3-none-macosx_11_0_arm64.whl"
+  },
   {
     "version": "0.6.17",
     "url": "https://files.pythonhosted.org/packages/a5/4f/66c7153120c155446f319647c1bafec2d9288f2b48d769cd9f9da39aa1f2/uv-0.6.17-py3-none-macosx_11_0_arm64.whl",
@@ -55,6 +195,13 @@
     "uploaded": "2025-04-25T18:51:15.410083Z",
     "filename": "uv-0.6.17-py3-none-macosx_11_0_arm64.whl"
   },
+  {
+    "version": "0.7.0",
+    "url": "https://files.pythonhosted.org/packages/ed/1d/cad304d6107208fdd90adf5ca519e86a2e35786cb7229d6cd39cf29bec3d/uv-0.7.0-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "1f48eeaeb46a5f81be873c1662c999e78ff267798ecea9dd48c7082e022048ec",
+    "uploaded": "2025-04-29T22:03:35.477030Z",
+    "filename": "uv-0.7.0-py3-none-macosx_11_0_arm64.whl"
+  },
   {
     "version": "0.7.22",
     "url": "https://files.pythonhosted.org/packages/64/f5/0ee734f5e988fd8f26aad1f150703fe8c7d664029c9c677b989b69caf104/uv-0.7.22-py3-none-macosx_11_0_arm64.whl",
@@ -62,6 +209,27 @@
     "uploaded": "2025-07-17T17:00:10.010548Z",
     "filename": "uv-0.7.22-py3-none-macosx_11_0_arm64.whl"
   },
+  {
+    "version": "0.8.0",
+    "url": "https://files.pythonhosted.org/packages/9d/98/9a89983caa05cf998eea3dac1e6cff2e0ab8099be0695fd8b9dc6a5038a0/uv-0.8.0-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "2d0ebf05eaee75921b3f23e7401a56bc0732bcdabb7469081ab00769340a93b4",
+    "uploaded": "2025-07-17T22:51:04.941749Z",
+    "filename": "uv-0.8.0-py3-none-macosx_11_0_arm64.whl"
+  },
+  {
+    "version": "0.8.3",
+    "url": "https://files.pythonhosted.org/packages/9c/ba/8ceec5d6a1adf6b827db557077d8059e573a84c3708a70433d22a0470fab/uv-0.8.3-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "3f904f574dc2d7aa1d96ddf2483480ecd121dc9d060108cadd8bff100b754b64",
+    "uploaded": "2025-07-24T21:13:57.570096Z",
+    "filename": "uv-0.8.3-py3-none-macosx_11_0_arm64.whl"
+  },
+  {
+    "version": "0.8.4",
+    "url": "https://files.pythonhosted.org/packages/16/39/7d4b68132868c550ae97c3b2c348c55db47a987dff05ab0e5f577bf0e197/uv-0.8.4-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "edc813645348665a3b4716a7d5e961cf7c8d1d3bfb9d907a4f18cf87c712a430",
+    "uploaded": "2025-07-30T17:10:20.417141Z",
+    "filename": "uv-0.8.4-py3-none-macosx_11_0_arm64.whl"
+  },
   {
     "version": "0.8.24",
     "url": "https://files.pythonhosted.org/packages/ea/00/08f4e93989129bb3378f20315dddcac6f8cf26a12bdd90443a340e7ecdb4/uv-0.8.24-py3-none-macosx_11_0_arm64.whl",
@@ -69,6 +237,13 @@
     "uploaded": "2025-10-07T03:33:24.533046Z",
     "filename": "uv-0.8.24-py3-none-macosx_11_0_arm64.whl"
   },
+  {
+    "version": "0.9.0",
+    "url": "https://files.pythonhosted.org/packages/8e/06/f5e38314e318bfaa20ccce966f6d0a69b093854648d31085b2d8b2097aab/uv-0.9.0-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "b900e84d992a657e16371426dbb030ab031c0322a604b632dada34401ebe7145",
+    "uploaded": "2025-10-07T23:44:30.076333Z",
+    "filename": "uv-0.9.0-py3-none-macosx_11_0_arm64.whl"
+  },
   {
     "version": "0.9.30",
     "url": "https://files.pythonhosted.org/packages/42/5f/3ccc9415ef62969ed01829572338ea7bdf4c5cf1ffb9edc1f8cb91b571f3/uv-0.9.30-py3-none-macosx_11_0_arm64.whl",
@@ -76,6 +251,13 @@
     "uploaded": "2026-02-04T21:45:40.881824Z",
     "filename": "uv-0.9.30-py3-none-macosx_11_0_arm64.whl"
   },
+  {
+    "version": "0.10.0",
+    "url": "https://files.pythonhosted.org/packages/ee/77/ec8f24f8d0f19c4fda0718d917bb78b9e6f02a4e1963b401f1c4f4614a54/uv-0.10.0-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "aefea608971f4f23ac3dac2006afb8eb2b2c1a2514f5fee1fac18e6c45fd70c4",
+    "uploaded": "2026-02-05T20:57:10.581974Z",
+    "filename": "uv-0.10.0-py3-none-macosx_11_0_arm64.whl"
+  },
   {
     "version": "0.10.12",
     "url": "https://files.pythonhosted.org/packages/ce/db/c41ace81b8ef5d5952433df38e321c0b6e5f88ce210c508b14f84817963f/uv-0.10.12-py3-none-macosx_11_0_arm64.whl",
@@ -83,6 +265,13 @@
     "uploaded": "2026-03-19T21:50:53.693778Z",
     "filename": "uv-0.10.12-py3-none-macosx_11_0_arm64.whl"
   },
+  {
+    "version": "0.11.0",
+    "url": "https://files.pythonhosted.org/packages/d9/1c/6ddd0febcea06cf23e59d9bff90d07025ecfd600238807f41ed2bdafd159/uv-0.11.0-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "4b0ebbd7ae019ea9fc4bff6a07d0c1e1d6784d1842bbdcb941982d30e2391972",
+    "uploaded": "2026-03-23T22:05:48.771767Z",
+    "filename": "uv-0.11.0-py3-none-macosx_11_0_arm64.whl"
+  },
   {
     "version": "0.11.33",
     "url": "https://files.pythonhosted.org/packages/4d/e5/17a4e36299e9bd5e8101680be697c7832afac686d1fe8b28be28046c1d95/uv-0.11.33-py3-none-macosx_11_0_arm64.whl",
@@ -91,10 +280,17 @@
     "filename": "uv-0.11.33-py3-none-macosx_11_0_arm64.whl"
   },
   {
-    "version": "0.12.13",
-    "url": "https://files.pythonhosted.org/packages/2a/33/ef14dc7c9c4cfaf0c3a4aed5a298b76b5dea94c75b233f7620c49c9b2e09/uv-0.12.13-py3-none-macosx_11_0_arm64.whl",
-    "sha256": "f86e5f02883c2e7a21bf522f4aa520c20d4f779d9a3368fbd6cdfe4a8f9549b5",
-    "uploaded": "2026-09-10T19:25:08.355776Z",
-    "filename": "uv-0.12.13-py3-none-macosx_11_0_arm64.whl"
+    "version": "0.12.0",
+    "url": "https://files.pythonhosted.org/packages/a5/7b/15d6865264120bd30c738b4bf63ddff66d087087cadeb2a6b88c6284a446/uv-0.12.0-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "009758d8fde2da2b90900f5fe863c71d0e1b8b28bbdba59863ceb967973a3735",
+    "uploaded": "2026-07-28T18:56:32.904863Z",
+    "filename": "uv-0.12.0-py3-none-macosx_11_0_arm64.whl"
+  },
+  {
+    "version": "0.12.15",
+    "url": "https://files.pythonhosted.org/packages/84/62/82e86e03e111463ab224c132c0f0e6b649d98d22710b177fbc000d379103/uv-0.12.15-py3-none-macosx_11_0_arm64.whl",
+    "sha256": "03b2c763f8b3c5595fa103221bc667e3af0146f8cb327aa06630ebcf5cfe16e9",
+    "uploaded": "2026-09-15T12:07:07.611580Z",
+    "filename": "uv-0.12.15-py3-none-macosx_11_0_arm64.whl"
   }
 ]
diff --git a/docs/testing/uv-compatibility/results.json b/docs/testing/uv-compatibility/results.json
index bbc3323e..d3721766 100644
--- a/docs/testing/uv-compatibility/results.json
+++ b/docs/testing/uv-compatibility/results.json
@@ -1,9 +1,10 @@
 {
-  "date": "2026-09-14",
-  "scope": "14 pinned uv releases on macOS-26.6.2-arm64-arm-64bit; interpreter /usr/bin/python3",
-  "socketPatchRevision": "e11bd419ea9c01b3ecd1aa894b55874718a3ff0a",
+  "date": "2026-09-15",
+  "scope": "42 pinned uv releases on macOS-26.6.2-arm64-arm-64bit-Mach-O; interpreter /usr/bin/python3",
+  "pythonVersion": "3.9.6",
+  "socketPatchRevision": "17d0dcb84bab1bec030117e0f111c7bfd893c2eb",
   "socketPatchVersion": "socket-patch 4.0.0",
-  "socketPatchBinarySha256": "eb5f6695a06c2124ac5c09f2117bf42e8777d767aec09c1de6ee16cd9dc4adee",
+  "socketPatchBinarySha256": "be7a0e3dd86d540b0dc038437410bec6042bcaad5ae8beba92fae23015b56548",
   "patchUuid": "e828efa5-5c6d-43f3-9909-03f5ac232b98",
   "originalWheelSha256": "34b97092d7e0a3a8cf7cd10e386f401b3737364026c45e622aa02903dffe0f07",
   "patchedWheelSha256": "ccc9a9e0b18a5efc7038c504cfc580e47d2e02e5390f2e29cad833cbccb956b6",
@@ -200,9 +201,7 @@
         "export",
         "--frozen",
         "--format",
-        "requirements-txt",
-        "--output-file",
-        "export-requirements.txt"
+        "requirements-txt"
       ],
       "cwd": "<output>/matrix/<uv-version>/project-hosted"
     },
@@ -212,8 +211,6 @@
         "export",
         "--frozen",
         "--format",
-        "pylock.toml",
-        "--output-file",
         "pylock.toml"
       ],
       "cwd": "<output>/matrix/<uv-version>/project-hosted"
@@ -260,15 +257,23 @@
       ],
       "cwd": "<output>/matrix/<uv-version>/project-hosted"
     },
+    "project-hosted-locked-install": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--locked",
+        "--python",
+        "/usr/bin/python3"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/project-unfrozen-hosted"
+    },
     "project-vendored-export-requirements-txt": {
       "args": [
         "<output>/bin/<uv-version>/uv",
         "export",
         "--frozen",
         "--format",
-        "requirements-txt",
-        "--output-file",
-        "export-requirements.txt"
+        "requirements-txt"
       ],
       "cwd": "<output>/matrix/<uv-version>/project-vendored"
     },
@@ -278,8 +283,6 @@
         "export",
         "--frozen",
         "--format",
-        "pylock.toml",
-        "--output-file",
         "pylock.toml"
       ],
       "cwd": "<output>/matrix/<uv-version>/project-vendored"
@@ -305,7 +308,7 @@
       ],
       "cwd": "<output>/matrix/<uv-version>/project-vendored"
     },
-    "project-hosted-locked-install": {
+    "project-vendored-locked-install": {
       "args": [
         "<output>/bin/<uv-version>/uv",
         "sync",
@@ -313,288 +316,17526 @@
         "--python",
         "/usr/bin/python3"
       ],
-      "cwd": "<output>/matrix/<uv-version>/project-unfrozen-hosted"
+      "cwd": "<output>/matrix/<uv-version>/project-unfrozen-vendored"
     },
-    "project-vendored-locked-install": {
+    "project-vendored-unfrozen-install": {
       "args": [
         "<output>/bin/<uv-version>/uv",
         "sync",
-        "--locked",
         "--python",
         "/usr/bin/python3"
       ],
       "cwd": "<output>/matrix/<uv-version>/project-unfrozen-vendored"
     },
-    "project-vendored-unfrozen-install": {
+    "variant-tool-uv-dev-hosted-lock": {
       "args": [
         "<output>/bin/<uv-version>/uv",
-        "sync",
+        "lock",
         "--python",
         "/usr/bin/python3"
       ],
-      "cwd": "<output>/matrix/<uv-version>/project-unfrozen-vendored"
+      "cwd": "<output>/matrix/<uv-version>/variant-tool-uv-dev-hosted"
     },
-    "project-hosted-lock-sync-variant-3": {
+    "variant-tool-uv-dev-hosted-socket-patch": {
+      "args": [
+        "<socket-patch>",
+        "scan",
+        "--cwd",
+        "<output>/matrix/<uv-version>/variant-tool-uv-dev-hosted",
+        "--mode",
+        "hosted",
+        "--json",
+        "--yes",
+        "--no-telemetry"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-tool-uv-dev-hosted"
+    },
+    "variant-tool-uv-dev-hosted-frozen-sync": {
       "args": [
         "<output>/bin/<uv-version>/uv",
         "sync",
-        "--python",
-        "/usr/bin/python3",
         "--frozen",
-        "--no-install-project"
+        "--python",
+        "/usr/bin/python3"
       ],
-      "cwd": "<output>/matrix/<uv-version>/project-hosted"
+      "cwd": "<output>/matrix/<uv-version>/variant-tool-uv-dev-hosted"
     },
-    "project-vendored-lock-sync-variant-2": {
+    "variant-tool-uv-dev-hosted-locked-sync": {
       "args": [
         "<output>/bin/<uv-version>/uv",
         "sync",
+        "--locked",
         "--python",
-        "/usr/bin/python3",
-        "--frozen",
-        "--no-install-project",
-        "--offline"
+        "/usr/bin/python3"
       ],
-      "cwd": "<output>/matrix/<uv-version>/project-vendored"
+      "cwd": "<output>/matrix/<uv-version>/variant-tool-uv-dev-hosted"
     },
-    "project-hosted-locked-install-variant-2": {
+    "variant-tool-uv-dev-hosted-plain-sync": {
       "args": [
         "<output>/bin/<uv-version>/uv",
         "sync",
-        "--locked",
         "--python",
-        "/usr/bin/python3",
-        "--no-install-project"
+        "/usr/bin/python3"
       ],
-      "cwd": "<output>/matrix/<uv-version>/project-unfrozen-hosted"
+      "cwd": "<output>/matrix/<uv-version>/variant-tool-uv-dev-hosted"
     },
-    "project-hosted-unfrozen-install-variant-2": {
+    "variant-tool-uv-dev-vendored-lock": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "lock",
+        "--python",
+        "/usr/bin/python3"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-tool-uv-dev-vendored"
+    },
+    "variant-tool-uv-dev-vendored-socket-patch": {
+      "args": [
+        "<socket-patch>",
+        "scan",
+        "--cwd",
+        "<output>/matrix/<uv-version>/variant-tool-uv-dev-vendored",
+        "--mode",
+        "vendored",
+        "--json",
+        "--yes",
+        "--no-telemetry"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-tool-uv-dev-vendored"
+    },
+    "variant-tool-uv-dev-vendored-frozen-sync": {
       "args": [
         "<output>/bin/<uv-version>/uv",
         "sync",
+        "--frozen",
         "--python",
-        "/usr/bin/python3",
-        "--no-install-project"
+        "/usr/bin/python3"
       ],
-      "cwd": "<output>/matrix/<uv-version>/project-unfrozen-hosted"
+      "cwd": "<output>/matrix/<uv-version>/variant-tool-uv-dev-vendored"
     },
-    "project-vendored-locked-install-variant-2": {
+    "variant-tool-uv-dev-vendored-locked-sync": {
       "args": [
         "<output>/bin/<uv-version>/uv",
         "sync",
         "--locked",
         "--python",
-        "/usr/bin/python3",
-        "--no-install-project"
+        "/usr/bin/python3"
       ],
-      "cwd": "<output>/matrix/<uv-version>/project-unfrozen-vendored"
+      "cwd": "<output>/matrix/<uv-version>/variant-tool-uv-dev-vendored"
     },
-    "project-vendored-unfrozen-install-variant-2": {
+    "variant-tool-uv-dev-vendored-plain-sync": {
       "args": [
         "<output>/bin/<uv-version>/uv",
         "sync",
         "--python",
-        "/usr/bin/python3",
-        "--no-install-project"
+        "/usr/bin/python3"
       ],
-      "cwd": "<output>/matrix/<uv-version>/project-unfrozen-vendored"
+      "cwd": "<output>/matrix/<uv-version>/variant-tool-uv-dev-vendored"
     },
-    "requirements-hosted-export-sync": {
+    "variant-dependency-groups-hosted-lock": {
       "args": [
         "<output>/bin/<uv-version>/uv",
-        "pip",
-        "sync",
-        "requirements.txt"
+        "lock",
+        "--python",
+        "/usr/bin/python3"
       ],
-      "cwd": "<output>/matrix/<uv-version>/export-requirements-hosted"
+      "cwd": "<output>/matrix/<uv-version>/variant-dependency-groups-hosted"
     },
-    "requirements-vendored-export-sync": {
+    "variant-dependency-groups-vendored-lock": {
       "args": [
         "<output>/bin/<uv-version>/uv",
-        "pip",
-        "sync",
-        "requirements.txt",
-        "--offline"
+        "lock",
+        "--python",
+        "/usr/bin/python3"
       ],
-      "cwd": "<output>/matrix/<uv-version>/export-requirements-vendored"
+      "cwd": "<output>/matrix/<uv-version>/variant-dependency-groups-vendored"
     },
-    "script-direct-hosted-socket-patch": {
+    "variant-extras-duplicate-hosted-lock": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "lock",
+        "--python",
+        "/usr/bin/python3"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-extras-duplicate-hosted"
+    },
+    "variant-extras-duplicate-hosted-socket-patch": {
       "args": [
         "<socket-patch>",
         "scan",
         "--cwd",
-        "<output>/matrix/<uv-version>/script-direct-hosted",
+        "<output>/matrix/<uv-version>/variant-extras-duplicate-hosted",
         "--mode",
         "hosted",
         "--json",
         "--yes",
         "--no-telemetry"
       ],
-      "cwd": "<output>/matrix/<uv-version>/script-direct-hosted"
+      "cwd": "<output>/matrix/<uv-version>/variant-extras-duplicate-hosted"
     },
-    "script-direct-hosted-install": {
+    "variant-extras-duplicate-hosted-frozen-sync": {
       "args": [
         "<output>/bin/<uv-version>/uv",
-        "run",
+        "sync",
         "--frozen",
         "--python",
-        "/usr/bin/python3",
-        "--script",
-        "example.py"
+        "/usr/bin/python3"
       ],
-      "cwd": "<output>/matrix/<uv-version>/script-direct-hosted"
+      "cwd": "<output>/matrix/<uv-version>/variant-extras-duplicate-hosted"
     },
-    "script-direct-vendored-socket-patch": {
+    "variant-extras-duplicate-hosted-locked-sync": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--locked",
+        "--python",
+        "/usr/bin/python3"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-extras-duplicate-hosted"
+    },
+    "variant-extras-duplicate-hosted-plain-sync": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--python",
+        "/usr/bin/python3"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-extras-duplicate-hosted"
+    },
+    "variant-extras-duplicate-vendored-lock": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "lock",
+        "--python",
+        "/usr/bin/python3"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-extras-duplicate-vendored"
+    },
+    "variant-extras-duplicate-vendored-socket-patch": {
       "args": [
         "<socket-patch>",
         "scan",
         "--cwd",
-        "<output>/matrix/<uv-version>/script-direct-vendored",
+        "<output>/matrix/<uv-version>/variant-extras-duplicate-vendored",
         "--mode",
         "vendored",
         "--json",
         "--yes",
         "--no-telemetry"
       ],
-      "cwd": "<output>/matrix/<uv-version>/script-direct-vendored"
+      "cwd": "<output>/matrix/<uv-version>/variant-extras-duplicate-vendored"
     },
-    "script-direct-vendored-install": {
+    "variant-extras-duplicate-vendored-frozen-sync": {
       "args": [
         "<output>/bin/<uv-version>/uv",
-        "run",
-        "--offline",
+        "sync",
         "--frozen",
         "--python",
-        "/usr/bin/python3",
-        "--script",
-        "example.py"
+        "/usr/bin/python3"
       ],
-      "cwd": "<output>/matrix/<uv-version>/script-direct-vendored"
+      "cwd": "<output>/matrix/<uv-version>/variant-extras-duplicate-vendored"
     },
-    "script-hosted-locked-install": {
+    "variant-extras-duplicate-vendored-locked-sync": {
       "args": [
         "<output>/bin/<uv-version>/uv",
-        "run",
+        "sync",
         "--locked",
         "--python",
-        "/usr/bin/python3",
-        "--script",
-        "example.py"
+        "/usr/bin/python3"
       ],
-      "cwd": "<output>/matrix/<uv-version>/script-unfrozen-hosted"
+      "cwd": "<output>/matrix/<uv-version>/variant-extras-duplicate-vendored"
     },
-    "script-hosted-unfrozen-install": {
+    "variant-extras-duplicate-vendored-plain-sync": {
       "args": [
         "<output>/bin/<uv-version>/uv",
-        "run",
+        "sync",
         "--python",
-        "/usr/bin/python3",
-        "--script",
-        "example.py"
+        "/usr/bin/python3"
       ],
-      "cwd": "<output>/matrix/<uv-version>/script-unfrozen-hosted"
+      "cwd": "<output>/matrix/<uv-version>/variant-extras-duplicate-vendored"
     },
-    "script-vendored-locked-install": {
+    "variant-constraints-hosted-lock": {
       "args": [
         "<output>/bin/<uv-version>/uv",
-        "run",
-        "--locked",
+        "lock",
         "--python",
-        "/usr/bin/python3",
-        "--script",
-        "example.py"
+        "/usr/bin/python3"
       ],
-      "cwd": "<output>/matrix/<uv-version>/script-unfrozen-vendored"
+      "cwd": "<output>/matrix/<uv-version>/variant-constraints-hosted"
     },
-    "script-vendored-unfrozen-install": {
+    "variant-constraints-vendored-lock": {
       "args": [
         "<output>/bin/<uv-version>/uv",
-        "run",
+        "lock",
         "--python",
-        "/usr/bin/python3",
-        "--script",
-        "example.py"
-      ],
-      "cwd": "<output>/matrix/<uv-version>/script-unfrozen-vendored"
-    },
-    "pylock-hosted-export-sync": {
-      "args": [
-        "<output>/bin/<uv-version>/uv",
-        "pip",
-        "sync",
-        "pylock.toml"
+        "/usr/bin/python3"
       ],
-      "cwd": "<output>/matrix/<uv-version>/export-pylock-hosted"
+      "cwd": "<output>/matrix/<uv-version>/variant-constraints-vendored"
     },
-    "pylock-vendored-export-sync": {
+    "variant-transitive-hosted-lock": {
       "args": [
         "<output>/bin/<uv-version>/uv",
-        "pip",
-        "sync",
-        "pylock.toml",
-        "--offline"
+        "lock",
+        "--python",
+        "/usr/bin/python3"
       ],
-      "cwd": "<output>/matrix/<uv-version>/export-pylock-vendored"
+      "cwd": "<output>/matrix/<uv-version>/variant-transitive-hosted"
     },
-    "pylock-direct-hosted-socket-patch": {
+    "variant-transitive-hosted-socket-patch": {
       "args": [
         "<socket-patch>",
         "scan",
         "--cwd",
-        "<output>/matrix/<uv-version>/pylock-direct-hosted",
+        "<output>/matrix/<uv-version>/variant-transitive-hosted",
         "--mode",
         "hosted",
         "--json",
         "--yes",
         "--no-telemetry"
       ],
-      "cwd": "<output>/matrix/<uv-version>/pylock-direct-hosted"
+      "cwd": "<output>/matrix/<uv-version>/variant-transitive-hosted"
     },
-    "pylock-direct-hosted-install": {
+    "variant-transitive-hosted-frozen-sync": {
       "args": [
         "<output>/bin/<uv-version>/uv",
-        "pip",
         "sync",
-        "pylock.toml"
+        "--frozen",
+        "--python",
+        "/usr/bin/python3"
       ],
-      "cwd": "<output>/matrix/<uv-version>/pylock-direct-hosted"
+      "cwd": "<output>/matrix/<uv-version>/variant-transitive-hosted"
     },
-    "pylock-direct-vendored-socket-patch": {
+    "variant-transitive-hosted-locked-sync": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--locked",
+        "--python",
+        "/usr/bin/python3"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-transitive-hosted"
+    },
+    "variant-transitive-hosted-plain-sync": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--python",
+        "/usr/bin/python3"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-transitive-hosted"
+    },
+    "variant-transitive-vendored-lock": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "lock",
+        "--python",
+        "/usr/bin/python3"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-transitive-vendored"
+    },
+    "variant-transitive-vendored-socket-patch": {
       "args": [
         "<socket-patch>",
         "scan",
         "--cwd",
-        "<output>/matrix/<uv-version>/pylock-direct-vendored",
+        "<output>/matrix/<uv-version>/variant-transitive-vendored",
         "--mode",
         "vendored",
         "--json",
         "--yes",
         "--no-telemetry"
       ],
-      "cwd": "<output>/matrix/<uv-version>/pylock-direct-vendored"
+      "cwd": "<output>/matrix/<uv-version>/variant-transitive-vendored"
     },
-    "pylock-direct-vendored-install": {
+    "variant-transitive-vendored-frozen-sync": {
       "args": [
         "<output>/bin/<uv-version>/uv",
-        "pip",
-        "--offline",
         "sync",
-        "pylock.toml"
+        "--frozen",
+        "--python",
+        "/usr/bin/python3"
       ],
-      "cwd": "<output>/matrix/<uv-version>/pylock-direct-vendored"
-    }
-  },
-  "versions": [
-    {
+      "cwd": "<output>/matrix/<uv-version>/variant-transitive-vendored"
+    },
+    "variant-transitive-vendored-locked-sync": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--locked",
+        "--python",
+        "/usr/bin/python3"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-transitive-vendored"
+    },
+    "variant-transitive-vendored-plain-sync": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--python",
+        "/usr/bin/python3"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-transitive-vendored"
+    },
+    "variant-constraints-hosted-socket-patch": {
+      "args": [
+        "<socket-patch>",
+        "scan",
+        "--cwd",
+        "<output>/matrix/<uv-version>/variant-constraints-hosted",
+        "--mode",
+        "hosted",
+        "--json",
+        "--yes",
+        "--no-telemetry"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-constraints-hosted"
+    },
+    "variant-constraints-hosted-frozen-sync": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--frozen",
+        "--python",
+        "/usr/bin/python3"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-constraints-hosted"
+    },
+    "variant-constraints-hosted-locked-sync": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--locked",
+        "--python",
+        "/usr/bin/python3"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-constraints-hosted"
+    },
+    "variant-constraints-hosted-plain-sync": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--python",
+        "/usr/bin/python3"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-constraints-hosted"
+    },
+    "variant-constraints-vendored-socket-patch": {
+      "args": [
+        "<socket-patch>",
+        "scan",
+        "--cwd",
+        "<output>/matrix/<uv-version>/variant-constraints-vendored",
+        "--mode",
+        "vendored",
+        "--json",
+        "--yes",
+        "--no-telemetry"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-constraints-vendored"
+    },
+    "variant-constraints-vendored-frozen-sync": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--frozen",
+        "--python",
+        "/usr/bin/python3"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-constraints-vendored"
+    },
+    "variant-constraints-vendored-locked-sync": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--locked",
+        "--python",
+        "/usr/bin/python3"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-constraints-vendored"
+    },
+    "variant-constraints-vendored-plain-sync": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--python",
+        "/usr/bin/python3"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-constraints-vendored"
+    },
+    "project-hosted-lock-sync-variant-3": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--python",
+        "/usr/bin/python3",
+        "--frozen",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/project-hosted"
+    },
+    "project-vendored-lock-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--python",
+        "/usr/bin/python3",
+        "--frozen",
+        "--no-install-project",
+        "--offline"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/project-vendored"
+    },
+    "project-hosted-locked-install-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--locked",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/project-unfrozen-hosted"
+    },
+    "project-hosted-unfrozen-install-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/project-unfrozen-hosted"
+    },
+    "project-vendored-locked-install-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--locked",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/project-unfrozen-vendored"
+    },
+    "project-vendored-unfrozen-install-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/project-unfrozen-vendored"
+    },
+    "variant-tool-uv-dev-hosted-frozen-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--frozen",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-tool-uv-dev-hosted"
+    },
+    "variant-tool-uv-dev-hosted-locked-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--locked",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-tool-uv-dev-hosted"
+    },
+    "variant-tool-uv-dev-hosted-plain-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-tool-uv-dev-hosted"
+    },
+    "variant-tool-uv-dev-vendored-frozen-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--frozen",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-tool-uv-dev-vendored"
+    },
+    "variant-tool-uv-dev-vendored-locked-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--locked",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-tool-uv-dev-vendored"
+    },
+    "variant-tool-uv-dev-vendored-plain-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-tool-uv-dev-vendored"
+    },
+    "variant-extras-duplicate-hosted-frozen-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--frozen",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-extras-duplicate-hosted"
+    },
+    "variant-extras-duplicate-hosted-locked-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--locked",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-extras-duplicate-hosted"
+    },
+    "variant-extras-duplicate-hosted-plain-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-extras-duplicate-hosted"
+    },
+    "variant-extras-duplicate-vendored-frozen-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--frozen",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-extras-duplicate-vendored"
+    },
+    "variant-extras-duplicate-vendored-locked-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--locked",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-extras-duplicate-vendored"
+    },
+    "variant-extras-duplicate-vendored-plain-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-extras-duplicate-vendored"
+    },
+    "variant-constraints-hosted-frozen-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--frozen",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-constraints-hosted"
+    },
+    "variant-constraints-hosted-locked-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--locked",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-constraints-hosted"
+    },
+    "variant-constraints-hosted-plain-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-constraints-hosted"
+    },
+    "variant-constraints-vendored-frozen-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--frozen",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-constraints-vendored"
+    },
+    "variant-constraints-vendored-locked-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--locked",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-constraints-vendored"
+    },
+    "variant-constraints-vendored-plain-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-constraints-vendored"
+    },
+    "variant-transitive-hosted-frozen-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--frozen",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-transitive-hosted"
+    },
+    "variant-transitive-hosted-locked-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--locked",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-transitive-hosted"
+    },
+    "variant-transitive-hosted-plain-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-transitive-hosted"
+    },
+    "variant-transitive-vendored-frozen-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--frozen",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-transitive-vendored"
+    },
+    "variant-transitive-vendored-locked-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--locked",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-transitive-vendored"
+    },
+    "variant-transitive-vendored-plain-sync-variant-2": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-transitive-vendored"
+    },
+    "requirements-hosted-export-sync": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "pip",
+        "sync",
+        "requirements.txt"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/export-requirements-hosted"
+    },
+    "requirements-vendored-export-sync": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "pip",
+        "sync",
+        "requirements.txt",
+        "--offline"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/export-requirements-vendored"
+    },
+    "variant-dependency-groups-hosted-socket-patch": {
+      "args": [
+        "<socket-patch>",
+        "scan",
+        "--cwd",
+        "<output>/matrix/<uv-version>/variant-dependency-groups-hosted",
+        "--mode",
+        "hosted",
+        "--json",
+        "--yes",
+        "--no-telemetry"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-dependency-groups-hosted"
+    },
+    "variant-dependency-groups-hosted-frozen-sync": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--frozen",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-dependency-groups-hosted"
+    },
+    "variant-dependency-groups-hosted-locked-sync": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--locked",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-dependency-groups-hosted"
+    },
+    "variant-dependency-groups-hosted-plain-sync": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-dependency-groups-hosted"
+    },
+    "variant-dependency-groups-vendored-socket-patch": {
+      "args": [
+        "<socket-patch>",
+        "scan",
+        "--cwd",
+        "<output>/matrix/<uv-version>/variant-dependency-groups-vendored",
+        "--mode",
+        "vendored",
+        "--json",
+        "--yes",
+        "--no-telemetry"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-dependency-groups-vendored"
+    },
+    "variant-dependency-groups-vendored-frozen-sync": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--frozen",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-dependency-groups-vendored"
+    },
+    "variant-dependency-groups-vendored-locked-sync": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--locked",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-dependency-groups-vendored"
+    },
+    "variant-dependency-groups-vendored-plain-sync": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "sync",
+        "--python",
+        "/usr/bin/python3",
+        "--no-install-project"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/variant-dependency-groups-vendored"
+    },
+    "script-direct-hosted-socket-patch": {
+      "args": [
+        "<socket-patch>",
+        "scan",
+        "--cwd",
+        "<output>/matrix/<uv-version>/script-direct-hosted",
+        "--mode",
+        "hosted",
+        "--json",
+        "--yes",
+        "--no-telemetry"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/script-direct-hosted"
+    },
+    "script-direct-hosted-install": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "run",
+        "--frozen",
+        "--python",
+        "/usr/bin/python3",
+        "--script",
+        "example.py"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/script-direct-hosted"
+    },
+    "script-direct-vendored-socket-patch": {
+      "args": [
+        "<socket-patch>",
+        "scan",
+        "--cwd",
+        "<output>/matrix/<uv-version>/script-direct-vendored",
+        "--mode",
+        "vendored",
+        "--json",
+        "--yes",
+        "--no-telemetry"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/script-direct-vendored"
+    },
+    "script-direct-vendored-install": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "run",
+        "--offline",
+        "--frozen",
+        "--python",
+        "/usr/bin/python3",
+        "--script",
+        "example.py"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/script-direct-vendored"
+    },
+    "script-hosted-locked-install": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "run",
+        "--locked",
+        "--python",
+        "/usr/bin/python3",
+        "--script",
+        "example.py"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/script-unfrozen-hosted"
+    },
+    "script-hosted-unfrozen-install": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "run",
+        "--python",
+        "/usr/bin/python3",
+        "--script",
+        "example.py"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/script-unfrozen-hosted"
+    },
+    "script-vendored-locked-install": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "run",
+        "--locked",
+        "--python",
+        "/usr/bin/python3",
+        "--script",
+        "example.py"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/script-unfrozen-vendored"
+    },
+    "script-vendored-unfrozen-install": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "run",
+        "--python",
+        "/usr/bin/python3",
+        "--script",
+        "example.py"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/script-unfrozen-vendored"
+    },
+    "pylock-hosted-export-sync": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "pip",
+        "sync",
+        "pylock.toml"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/export-pylock-hosted"
+    },
+    "pylock-vendored-export-sync": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "pip",
+        "sync",
+        "pylock.toml",
+        "--offline"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/export-pylock-vendored"
+    },
+    "pylock-direct-hosted-socket-patch": {
+      "args": [
+        "<socket-patch>",
+        "scan",
+        "--cwd",
+        "<output>/matrix/<uv-version>/pylock-direct-hosted",
+        "--mode",
+        "hosted",
+        "--json",
+        "--yes",
+        "--no-telemetry"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/pylock-direct-hosted"
+    },
+    "pylock-direct-hosted-install": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "pip",
+        "sync",
+        "pylock.toml"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/pylock-direct-hosted"
+    },
+    "pylock-direct-vendored-socket-patch": {
+      "args": [
+        "<socket-patch>",
+        "scan",
+        "--cwd",
+        "<output>/matrix/<uv-version>/pylock-direct-vendored",
+        "--mode",
+        "vendored",
+        "--json",
+        "--yes",
+        "--no-telemetry"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/pylock-direct-vendored"
+    },
+    "pylock-direct-vendored-install": {
+      "args": [
+        "<output>/bin/<uv-version>/uv",
+        "pip",
+        "--offline",
+        "sync",
+        "pylock.toml"
+      ],
+      "cwd": "<output>/matrix/<uv-version>/pylock-direct-vendored"
+    }
+  },
+  "versions": [
+    {
       "version": "0.0.5",
       "lockSchema": null,
       "lockVersion": null,
       "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": null,
+          "vendored": null
+        },
+        "dependency-groups": {
+          "hosted": null,
+          "vendored": null
+        },
+        "extras-duplicate": {
+          "hosted": null,
+          "vendored": null
+        },
+        "constraints": {
+          "hosted": null,
+          "vendored": null
+        },
+        "transitive": {
+          "hosted": null,
+          "vendored": null
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'lock'\n\n  tip: a similar subcommand exists: 'uv pip compile'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 2,
+          "diagnostic": "error: Unexpected '.', expected '-c', '-e', '-r' or the start of a requirement in `requirements.txt` at position 144\n"
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 2,
+          "diagnostic": "error: Unexpected '.', expected '-c', '-e', '-r' or the start of a requirement in `requirements.txt` at position 126\n"
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'lock'\n\n  tip: a similar subcommand exists: 'uv pip compile'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'lock'\n\n  tip: a similar subcommand exists: 'uv pip compile'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        }
+      ]
+    },
+    {
+      "version": "0.1.0",
+      "lockSchema": null,
+      "lockVersion": null,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": null,
+          "vendored": null
+        },
+        "dependency-groups": {
+          "hosted": null,
+          "vendored": null
+        },
+        "extras-duplicate": {
+          "hosted": null,
+          "vendored": null
+        },
+        "constraints": {
+          "hosted": null,
+          "vendored": null
+        },
+        "transitive": {
+          "hosted": null,
+          "vendored": null
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'lock'\n\n  tip: a similar subcommand exists: 'uv pip compile'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 2,
+          "diagnostic": "error: Unexpected '.', expected '-c', '-e', '-r' or the start of a requirement in `requirements.txt` at position 144\n"
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 2,
+          "diagnostic": "error: Unexpected '.', expected '-c', '-e', '-r' or the start of a requirement in `requirements.txt` at position 126\n"
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'lock'\n\n  tip: a similar subcommand exists: 'uv pip compile'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'lock'\n\n  tip: a similar subcommand exists: 'uv pip compile'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        }
+      ]
+    },
+    {
+      "version": "0.1.23",
+      "lockSchema": null,
+      "lockVersion": null,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": null,
+          "vendored": null
+        },
+        "dependency-groups": {
+          "hosted": null,
+          "vendored": null
+        },
+        "extras-duplicate": {
+          "hosted": null,
+          "vendored": null
+        },
+        "constraints": {
+          "hosted": null,
+          "vendored": null
+        },
+        "transitive": {
+          "hosted": null,
+          "vendored": null
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'lock'\n\n  tip: a similar subcommand exists: 'uv pip compile'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 2,
+          "diagnostic": "error: Unexpected '.', expected '-c', '-e', '-r' or the start of a requirement at requirements.txt:3:1\n"
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 2,
+          "diagnostic": "error: Unexpected '.', expected '-c', '-e', '-r' or the start of a requirement at requirements.txt:3:1\n"
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'lock'\n\n  tip: a similar subcommand exists: 'uv pip compile'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'lock'\n\n  tip: a similar subcommand exists: 'uv pip compile'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        }
+      ]
+    },
+    {
+      "version": "0.1.24",
+      "lockSchema": null,
+      "lockVersion": null,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": null,
+          "vendored": null
+        },
+        "dependency-groups": {
+          "hosted": null,
+          "vendored": null
+        },
+        "extras-duplicate": {
+          "hosted": null,
+          "vendored": null
+        },
+        "constraints": {
+          "hosted": null,
+          "vendored": null
+        },
+        "transitive": {
+          "hosted": null,
+          "vendored": null
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'lock'\n\n  tip: a similar subcommand exists: 'uv pip compile'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'lock'\n\n  tip: a similar subcommand exists: 'uv pip compile'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'lock'\n\n  tip: a similar subcommand exists: 'uv pip compile'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        }
+      ]
+    },
+    {
+      "version": "0.1.44",
+      "lockSchema": null,
+      "lockVersion": null,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": null,
+          "vendored": null
+        },
+        "dependency-groups": {
+          "hosted": null,
+          "vendored": null
+        },
+        "extras-duplicate": {
+          "hosted": null,
+          "vendored": null
+        },
+        "constraints": {
+          "hosted": null,
+          "vendored": null
+        },
+        "transitive": {
+          "hosted": null,
+          "vendored": null
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 101,
+          "diagnostic": "warning: `uv lock` is experimental and may change without warning.\nUsing Python 3.14.3 interpreter at: /opt/homebrew/opt/python@3.14/bin/python3.14\nCreating virtualenv at: .venv\nResolved 2 packages in 538ms\nthread 'main' panicked at crates/uv-resolver/src/lock.rs:304:40:\nnot yet implemented\nnote: run with `RUST_BACKTRACE=1` environment variable to display a backtrace\n"
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        }
+      ]
+    },
+    {
+      "version": "0.1.45",
+      "lockSchema": "distribution",
+      "lockVersion": 1,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": null,
+          "vendored": null
+        },
+        "dependency-groups": {
+          "hosted": null,
+          "vendored": null
+        },
+        "extras-duplicate": {
+          "hosted": null,
+          "vendored": null
+        },
+        "constraints": {
+          "hosted": null,
+          "vendored": null
+        },
+        "transitive": {
+          "hosted": null,
+          "vendored": null
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-lock-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 1,
+          "vendorSummary": {
+            "applied": 0,
+            "failed": 1
+          },
+          "vendorErrors": [
+            {
+              "action": "failed",
+              "purl": "pkg:pypi/urllib3@1.26.18?artifact_id=py2-py3-none-any-whl",
+              "errorCode": "pypi_uv_legacy_lock_unsupported",
+              "error": "uv `[[distribution]]` lockfiles (uv < 0.2.35, experimental `uv lock`) cannot carry a portable local wheel: `--locked` rejects relative paths and `uv lock`/`uv sync` rewrite them to absolute ones; upgrade to uv >=0.2.35 for native vendoring, or use a requirements.txt installation"
+            }
+          ]
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "project-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        }
+      ]
+    },
+    {
+      "version": "0.2.0",
+      "lockSchema": "distribution",
+      "lockVersion": 1,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": null,
+          "vendored": null
+        },
+        "dependency-groups": {
+          "hosted": null,
+          "vendored": null
+        },
+        "extras-duplicate": {
+          "hosted": null,
+          "vendored": null
+        },
+        "constraints": {
+          "hosted": null,
+          "vendored": null
+        },
+        "transitive": {
+          "hosted": null,
+          "vendored": null
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-lock-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 1,
+          "vendorSummary": {
+            "applied": 0,
+            "failed": 1
+          },
+          "vendorErrors": [
+            {
+              "action": "failed",
+              "purl": "pkg:pypi/urllib3@1.26.18?artifact_id=py2-py3-none-any-whl",
+              "errorCode": "pypi_uv_legacy_lock_unsupported",
+              "error": "uv `[[distribution]]` lockfiles (uv < 0.2.35, experimental `uv lock`) cannot carry a portable local wheel: `--locked` rejects relative paths and `uv lock`/`uv sync` rewrite them to absolute ones; upgrade to uv >=0.2.35 for native vendoring, or use a requirements.txt installation"
+            }
+          ]
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "project-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        }
+      ]
+    },
+    {
+      "version": "0.2.5",
+      "lockSchema": "distribution",
+      "lockVersion": 1,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": null,
+          "vendored": null
+        },
+        "dependency-groups": {
+          "hosted": null,
+          "vendored": null
+        },
+        "extras-duplicate": {
+          "hosted": null,
+          "vendored": null
+        },
+        "constraints": {
+          "hosted": null,
+          "vendored": null
+        },
+        "transitive": {
+          "hosted": null,
+          "vendored": null
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-lock-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 1,
+          "vendorSummary": {
+            "applied": 0,
+            "failed": 1
+          },
+          "vendorErrors": [
+            {
+              "action": "failed",
+              "purl": "pkg:pypi/urllib3@1.26.18?artifact_id=py2-py3-none-any-whl",
+              "errorCode": "pypi_uv_legacy_lock_unsupported",
+              "error": "uv `[[distribution]]` lockfiles (uv < 0.2.35, experimental `uv lock`) cannot carry a portable local wheel: `--locked` rejects relative paths and `uv lock`/`uv sync` rewrite them to absolute ones; upgrade to uv >=0.2.35 for native vendoring, or use a requirements.txt installation"
+            }
+          ]
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "project-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        }
+      ]
+    },
+    {
+      "version": "0.2.6",
+      "lockSchema": "distribution",
+      "lockVersion": 1,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": null,
+          "vendored": null
+        },
+        "dependency-groups": {
+          "hosted": null,
+          "vendored": null
+        },
+        "extras-duplicate": {
+          "hosted": null,
+          "vendored": null
+        },
+        "constraints": {
+          "hosted": null,
+          "vendored": null
+        },
+        "transitive": {
+          "hosted": null,
+          "vendored": null
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-lock-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 1,
+          "vendorSummary": {
+            "applied": 0,
+            "failed": 1
+          },
+          "vendorErrors": [
+            {
+              "action": "failed",
+              "purl": "pkg:pypi/urllib3@1.26.18?artifact_id=py2-py3-none-any-whl",
+              "errorCode": "pypi_uv_legacy_lock_unsupported",
+              "error": "uv `[[distribution]]` lockfiles (uv < 0.2.35, experimental `uv lock`) cannot carry a portable local wheel: `--locked` rejects relative paths and `uv lock`/`uv sync` rewrite them to absolute ones; upgrade to uv >=0.2.35 for native vendoring, or use a requirements.txt installation"
+            }
+          ]
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "project-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        }
+      ]
+    },
+    {
+      "version": "0.2.17",
+      "lockSchema": "distribution",
+      "lockVersion": 1,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": null,
+          "vendored": null
+        },
+        "dependency-groups": {
+          "hosted": null,
+          "vendored": null
+        },
+        "extras-duplicate": {
+          "hosted": null,
+          "vendored": null
+        },
+        "constraints": {
+          "hosted": null,
+          "vendored": null
+        },
+        "transitive": {
+          "hosted": null,
+          "vendored": null
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-lock-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 1,
+          "vendorSummary": {
+            "applied": 0,
+            "failed": 1
+          },
+          "vendorErrors": [
+            {
+              "action": "failed",
+              "purl": "pkg:pypi/urllib3@1.26.18?artifact_id=py2-py3-none-any-whl",
+              "errorCode": "pypi_uv_legacy_lock_unsupported",
+              "error": "uv `[[distribution]]` lockfiles (uv < 0.2.35, experimental `uv lock`) cannot carry a portable local wheel: `--locked` rejects relative paths and `uv lock`/`uv sync` rewrite them to absolute ones; upgrade to uv >=0.2.35 for native vendoring, or use a requirements.txt installation"
+            }
+          ]
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "project-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        }
+      ]
+    },
+    {
+      "version": "0.2.18",
+      "lockSchema": "distribution",
+      "lockVersion": 1,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": null,
+          "vendored": null
+        },
+        "dependency-groups": {
+          "hosted": null,
+          "vendored": null
+        },
+        "extras-duplicate": {
+          "hosted": null,
+          "vendored": null
+        },
+        "constraints": {
+          "hosted": null,
+          "vendored": null
+        },
+        "transitive": {
+          "hosted": null,
+          "vendored": null
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-lock-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 1,
+          "vendorSummary": {
+            "applied": 0,
+            "failed": 1
+          },
+          "vendorErrors": [
+            {
+              "action": "failed",
+              "purl": "pkg:pypi/urllib3@1.26.18?artifact_id=py2-py3-none-any-whl",
+              "errorCode": "pypi_uv_legacy_lock_unsupported",
+              "error": "uv `[[distribution]]` lockfiles (uv < 0.2.35, experimental `uv lock`) cannot carry a portable local wheel: `--locked` rejects relative paths and `uv lock`/`uv sync` rewrite them to absolute ones; upgrade to uv >=0.2.35 for native vendoring, or use a requirements.txt installation"
+            }
+          ]
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "project-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        }
+      ]
+    },
+    {
+      "version": "0.2.34",
+      "lockSchema": "distribution",
+      "lockVersion": 1,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": null,
+          "vendored": null
+        },
+        "dependency-groups": {
+          "hosted": null,
+          "vendored": null
+        },
+        "extras-duplicate": {
+          "hosted": null,
+          "vendored": null
+        },
+        "constraints": {
+          "hosted": null,
+          "vendored": null
+        },
+        "transitive": {
+          "hosted": null,
+          "vendored": null
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 1,
+          "vendorSummary": {
+            "applied": 0,
+            "failed": 1
+          },
+          "vendorErrors": [
+            {
+              "action": "failed",
+              "purl": "pkg:pypi/urllib3@1.26.18?artifact_id=py2-py3-none-any-whl",
+              "errorCode": "pypi_uv_legacy_lock_unsupported",
+              "error": "uv `[[distribution]]` lockfiles (uv < 0.2.35, experimental `uv lock`) cannot carry a portable local wheel: `--locked` rejects relative paths and `uv lock`/`uv sync` rewrite them to absolute ones; upgrade to uv >=0.2.35 for native vendoring, or use a requirements.txt installation"
+            }
+          ]
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "project-hosted-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        }
+      ]
+    },
+    {
+      "version": "0.2.35",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "unsupported",
+          "vendored": "unsupported"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "unsupported",
+          "vendored": "unsupported"
+        },
+        "transitive": {
+          "hosted": [
+            "fail",
+            [
+              "locked",
+              "plain"
+            ]
+          ],
+          "vendored": [
+            "fail",
+            [
+              "locked",
+              "plain"
+            ]
+          ]
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-vendored-lock-sync",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "warning: `uv sync` is experimental and may change without warning\nUsing Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nerror: Failed to prepare distributions\n  Caused by: Failed to fetch wheel: socket-uv-patch-fixture @ file://<output>/matrix/0.2.35/project-vendored\n  Caused by: Failed to build: `socket-uv-patch-fixture @ file://<output>/matrix/0.2.35/project-vendored`\n  Caused by: Failed to install requirements from setup.py build (resolve)\n  Caused by: No solution found when resolving: setuptools>=40.8.0\n  Caused by: Because setuptools was not found in the cache and you require setuptools>=40.8.0, we can conclude that the requirements are unsatisfiable.\n\nhint: Packages were unavailable because the network was disabled\n"
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-frozen-sync-root-build-networked",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "project-hosted-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "warning: `uv sync` is experimental and may change without warning\nUsing Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nResolved 6 packages in 194ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "50f80b9a71e3e33ef56671fc8af60eca77004e27d33b0f4542e914a839dc9027",
+          "installedPatch": false
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "warning: `uv sync` is experimental and may change without warning\nUsing Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nResolved 6 packages in 334ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "50f80b9a71e3e33ef56671fc8af60eca77004e27d33b0f4542e914a839dc9027",
+          "installedPatch": false
+        }
+      ]
+    },
+    {
+      "version": "0.2.36",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "unsupported",
+          "vendored": "unsupported"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "unsupported",
+          "vendored": "unsupported"
+        },
+        "transitive": {
+          "hosted": [
+            "fail",
+            [
+              "locked",
+              "plain"
+            ]
+          ],
+          "vendored": [
+            "fail",
+            [
+              "locked",
+              "plain"
+            ]
+          ]
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-vendored-lock-sync",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "warning: `uv sync` is experimental and may change without warning\nUsing Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nerror: Failed to prepare distributions\n  Caused by: Failed to fetch wheel: socket-uv-patch-fixture @ file://<output>/matrix/0.2.36/project-vendored\n  Caused by: Failed to build: `socket-uv-patch-fixture @ file://<output>/matrix/0.2.36/project-vendored`\n  Caused by: Failed to install requirements from setup.py build (resolve)\n  Caused by: No solution found when resolving: setuptools>=40.8.0\n  Caused by: Because setuptools was not found in the cache and you require setuptools>=40.8.0, we can conclude that the requirements are unsatisfiable.\n\nhint: Packages were unavailable because the network was disabled\n"
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-frozen-sync-root-build-networked",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "project-hosted-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "warning: `uv sync` is experimental and may change without warning\nUsing Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nResolved 6 packages in 339ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "50f80b9a71e3e33ef56671fc8af60eca77004e27d33b0f4542e914a839dc9027",
+          "installedPatch": false
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "warning: `uv sync` is experimental and may change without warning\nUsing Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nResolved 6 packages in 211ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "50f80b9a71e3e33ef56671fc8af60eca77004e27d33b0f4542e914a839dc9027",
+          "installedPatch": false
+        }
+      ]
+    },
+    {
+      "version": "0.2.37",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "unsupported",
+          "vendored": "unsupported"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": [
+            "fail",
+            [
+              "locked"
+            ]
+          ],
+          "vendored": [
+            "fail",
+            [
+              "locked"
+            ]
+          ]
+        },
+        "transitive": {
+          "hosted": [
+            "fail",
+            [
+              "locked",
+              "plain"
+            ]
+          ],
+          "vendored": [
+            "fail",
+            [
+              "locked",
+              "plain"
+            ]
+          ]
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-vendored-lock-sync",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "warning: `uv sync` is experimental and may change without warning\nUsing Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nerror: Failed to prepare distributions\n  Caused by: Failed to fetch wheel: socket-uv-patch-fixture @ file://<output>/matrix/0.2.37/project-vendored\n  Caused by: Failed to install requirements from setup.py build (resolve)\n  Caused by: No solution found when resolving: setuptools>=40.8.0\n  Caused by: Because setuptools was not found in the cache and you require setuptools>=40.8.0, we can conclude that your requirements are unsatisfiable.\n\nhint: Packages were unavailable because the network was disabled\n"
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-frozen-sync-root-build-networked",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "project-hosted-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-constraints-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "warning: `uv sync` is experimental and may change without warning\nUsing Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nwarning: `uv.sources` is experimental and may change without warning\nResolved 2 packages in 7ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-constraints-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-locked-sync",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "warning: `uv sync` is experimental and may change without warning\nUsing Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nwarning: `uv.sources` is experimental and may change without warning\nResolved 2 packages in 3ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-constraints-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "warning: `uv sync` is experimental and may change without warning\nUsing Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nResolved 6 packages in 349ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "50f80b9a71e3e33ef56671fc8af60eca77004e27d33b0f4542e914a839dc9027",
+          "installedPatch": false
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "warning: `uv sync` is experimental and may change without warning\nUsing Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nResolved 6 packages in 539ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "50f80b9a71e3e33ef56671fc8af60eca77004e27d33b0f4542e914a839dc9027",
+          "installedPatch": false
+        }
+      ]
+    },
+    {
+      "version": "0.3.0",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "unsupported",
+          "vendored": "unsupported"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": [
+            "fail",
+            [
+              "locked"
+            ]
+          ],
+          "vendored": [
+            "fail",
+            [
+              "locked"
+            ]
+          ]
+        },
+        "transitive": {
+          "hosted": [
+            "fail",
+            [
+              "locked",
+              "plain"
+            ]
+          ],
+          "vendored": [
+            "fail",
+            [
+              "locked",
+              "plain"
+            ]
+          ]
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-vendored-lock-sync",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nerror: Failed to prepare distributions\n  Caused by: Failed to fetch wheel: socket-uv-patch-fixture @ file://<output>/matrix/0.3.0/project-vendored\n  Caused by: Failed to install requirements from setup.py build (resolve)\n  Caused by: No solution found when resolving: setuptools>=40.8.0\n  Caused by: Because setuptools was not found in the cache and you require setuptools>=40.8.0, we can conclude that your requirements are unsatisfiable.\n\nhint: Packages were unavailable because the network was disabled. When the network is disabled, registry packages may only be read from the cache.\n"
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-frozen-sync-root-build-networked",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "project-hosted-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-constraints-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nResolved 2 packages in 5ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-constraints-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-locked-sync",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nResolved 2 packages in 6ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-constraints-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nResolved 6 packages in 642ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "50f80b9a71e3e33ef56671fc8af60eca77004e27d33b0f4542e914a839dc9027",
+          "installedPatch": false
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nResolved 6 packages in 347ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "50f80b9a71e3e33ef56671fc8af60eca77004e27d33b0f4542e914a839dc9027",
+          "installedPatch": false
+        }
+      ]
+    },
+    {
+      "version": "0.3.5",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "unsupported",
+          "vendored": "unsupported"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": [
+            "fail",
+            [
+              "locked"
+            ]
+          ],
+          "vendored": [
+            "fail",
+            [
+              "locked"
+            ]
+          ]
+        },
+        "transitive": {
+          "hosted": [
+            "fail",
+            [
+              "locked",
+              "plain"
+            ]
+          ],
+          "vendored": [
+            "fail",
+            [
+              "locked",
+              "plain"
+            ]
+          ]
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-3",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-vendored-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "project-hosted-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nResolved 2 packages in 5ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nResolved 2 packages in 4ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nResolved 6 packages in 700ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "50f80b9a71e3e33ef56671fc8af60eca77004e27d33b0f4542e914a839dc9027",
+          "installedPatch": false
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nResolved 6 packages in 777ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "50f80b9a71e3e33ef56671fc8af60eca77004e27d33b0f4542e914a839dc9027",
+          "installedPatch": false
+        }
+      ]
+    },
+    {
+      "version": "0.4.0",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "unsupported",
+          "vendored": "unsupported"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": [
+            "fail",
+            [
+              "locked"
+            ]
+          ],
+          "vendored": [
+            "fail",
+            [
+              "locked"
+            ]
+          ]
+        },
+        "transitive": {
+          "hosted": [
+            "fail",
+            [
+              "locked",
+              "plain"
+            ]
+          ],
+          "vendored": [
+            "fail",
+            [
+              "locked",
+              "plain"
+            ]
+          ]
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-3",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-vendored-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "project-hosted-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nResolved 2 packages in 6ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nResolved 2 packages in 8ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nResolved 6 packages in 541ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "50f80b9a71e3e33ef56671fc8af60eca77004e27d33b0f4542e914a839dc9027",
+          "installedPatch": false
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nResolved 6 packages in 1.16s\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "50f80b9a71e3e33ef56671fc8af60eca77004e27d33b0f4542e914a839dc9027",
+          "installedPatch": false
+        }
+      ]
+    },
+    {
+      "version": "0.4.1",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "unsupported",
+          "vendored": "unsupported"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": [
+            "fail",
+            [
+              "locked"
+            ]
+          ],
+          "vendored": [
+            "fail",
+            [
+              "locked"
+            ]
+          ]
+        },
+        "transitive": {
+          "hosted": [
+            "fail",
+            [
+              "locked",
+              "plain"
+            ]
+          ],
+          "vendored": [
+            "fail",
+            [
+              "locked",
+              "plain"
+            ]
+          ]
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: invalid value 'pylock.toml' for '--format <FORMAT>'\n  [possible values: requirements-txt]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-3",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: invalid value 'pylock.toml' for '--format <FORMAT>'\n  [possible values: requirements-txt]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-vendored-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "project-hosted-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nResolved 2 packages in 4ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nResolved 2 packages in 6ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nResolved 6 packages in 1.03s\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "50f80b9a71e3e33ef56671fc8af60eca77004e27d33b0f4542e914a839dc9027",
+          "installedPatch": false
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nResolved 6 packages in 517ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "50f80b9a71e3e33ef56671fc8af60eca77004e27d33b0f4542e914a839dc9027",
+          "installedPatch": false
+        }
+      ]
+    },
+    {
+      "version": "0.4.30",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": [
+            "fail",
+            [
+              "locked"
+            ]
+          ],
+          "vendored": [
+            "fail",
+            [
+              "locked"
+            ]
+          ]
+        },
+        "transitive": {
+          "hosted": [
+            "fail",
+            [
+              "locked",
+              "plain"
+            ]
+          ],
+          "vendored": [
+            "fail",
+            [
+              "locked",
+              "plain"
+            ]
+          ]
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: invalid value 'pylock.toml' for '--format <FORMAT>'\n  [possible values: requirements-txt]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-3",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: invalid value 'pylock.toml' for '--format <FORMAT>'\n  [possible values: requirements-txt]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-vendored-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "project-hosted-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-dependency-groups-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-dependency-groups-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using CPython 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtual environment at: .venv\nResolved 2 packages in 18ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using CPython 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtual environment at: .venv\nResolved 2 packages in 8ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using CPython 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtual environment at: .venv\nResolved 6 packages in 321ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "50f80b9a71e3e33ef56671fc8af60eca77004e27d33b0f4542e914a839dc9027",
+          "installedPatch": false
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using CPython 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtual environment at: .venv\nResolved 6 packages in 312ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "50f80b9a71e3e33ef56671fc8af60eca77004e27d33b0f4542e914a839dc9027",
+          "installedPatch": false
+        }
+      ]
+    },
+    {
+      "version": "0.5.0",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": [
+            "fail",
+            [
+              "locked"
+            ]
+          ],
+          "vendored": [
+            "fail",
+            [
+              "locked"
+            ]
+          ]
+        },
+        "transitive": {
+          "hosted": [
+            "fail",
+            [
+              "locked",
+              "plain"
+            ]
+          ],
+          "vendored": [
+            "fail",
+            [
+              "locked",
+              "plain"
+            ]
+          ]
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: invalid value 'pylock.toml' for '--format <FORMAT>'\n  [possible values: requirements-txt]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-3",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: invalid value 'pylock.toml' for '--format <FORMAT>'\n  [possible values: requirements-txt]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-vendored-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "project-hosted-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-dependency-groups-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-dependency-groups-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using CPython 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtual environment at: .venv\nResolved 2 packages in 3ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using CPython 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtual environment at: .venv\nResolved 2 packages in 5ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using CPython 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtual environment at: .venv\nResolved 6 packages in 346ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "50f80b9a71e3e33ef56671fc8af60eca77004e27d33b0f4542e914a839dc9027",
+          "installedPatch": false
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
+          "exitCode": 2,
+          "lockUnchanged": true,
+          "diagnostic": "Using CPython 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtual environment at: .venv\nResolved 6 packages in 297ms\nerror: The lockfile at `uv.lock` needs to be updated, but `--locked` was provided. To update the lockfile, run `uv lock`.\n"
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": false,
+          "installedResponseSha256": "50f80b9a71e3e33ef56671fc8af60eca77004e27d33b0f4542e914a839dc9027",
+          "installedPatch": false
+        }
+      ]
+    },
+    {
+      "version": "0.5.16",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "transitive": {
+          "hosted": "pass",
+          "vendored": "pass"
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: invalid value 'pylock.toml' for '--format <FORMAT>'\n  [possible values: requirements-txt]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-3",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: invalid value 'pylock.toml' for '--format <FORMAT>'\n  [possible values: requirements-txt]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-vendored-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 2,
+          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "project-hosted-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-dependency-groups-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-dependency-groups-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        }
+      ]
+    },
+    {
+      "version": "0.5.17",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "transitive": {
+          "hosted": "pass",
+          "vendored": "pass"
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: invalid value 'pylock.toml' for '--format <FORMAT>'\n  [possible values: requirements-txt]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-3",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: invalid value 'pylock.toml' for '--format <FORMAT>'\n  [possible values: requirements-txt]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-vendored-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "example.py",
+            "example.py.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "script-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "script-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "project-hosted-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-dependency-groups-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-dependency-groups-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        }
+      ]
+    },
+    {
+      "version": "0.5.31",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": null,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "transitive": {
+          "hosted": "pass",
+          "vendored": "pass"
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: invalid value 'pylock.toml' for '--format <FORMAT>'\n  [possible values: requirements-txt]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-3",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: invalid value 'pylock.toml' for '--format <FORMAT>'\n  [possible values: requirements-txt]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-vendored-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "example.py",
+            "example.py.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "script-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "script-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "project-hosted-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-dependency-groups-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-dependency-groups-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        }
+      ]
+    },
+    {
+      "version": "0.6.0",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": 1,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "transitive": {
+          "hosted": "pass",
+          "vendored": "pass"
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: invalid value 'pylock.toml' for '--format <FORMAT>'\n  [possible values: requirements-txt]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-3",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: invalid value 'pylock.toml' for '--format <FORMAT>'\n  [possible values: requirements-txt]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-vendored-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "example.py",
+            "example.py.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "script-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "script-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": false
+        },
+        {
+          "command": "project-hosted-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-dependency-groups-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-dependency-groups-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        }
+      ]
+    },
+    {
+      "version": "0.6.14",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": 1,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "transitive": {
+          "hosted": "pass",
+          "vendored": "pass"
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: invalid value 'pylock.toml' for '--format <FORMAT>'\n  [possible values: requirements-txt]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-3",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 2,
+          "diagnostic": "error: invalid value 'pylock.toml' for '--format <FORMAT>'\n  [possible values: requirements-txt]\n\nFor more information, try '--help'.\n"
+        },
+        {
+          "command": "project-vendored-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "example.py",
+            "example.py.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "script-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "script-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 2,
+          "formatSupported": false,
+          "diagnostic": "error: TOML is not a supported output format for `uv pip compile` (only `requirements.txt`-style output is supported)\n"
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 2,
+          "formatSupported": false,
+          "diagnostic": "error: TOML is not a supported output format for `uv pip compile` (only `requirements.txt`-style output is supported)\n"
+        },
+        {
+          "command": "project-hosted-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-dependency-groups-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-dependency-groups-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        }
+      ]
+    },
+    {
+      "version": "0.6.15",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": 2,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "transitive": {
+          "hosted": "pass",
+          "vendored": "pass"
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-3",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "pylock-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "pylock-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "example.py",
+            "example.py.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "script-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "script-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pylock.toml"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "pylock-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "pylock-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-dependency-groups-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-dependency-groups-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        }
+      ]
+    },
+    {
+      "version": "0.6.17",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": 2,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "transitive": {
+          "hosted": "pass",
+          "vendored": "pass"
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-3",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "pylock-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "pylock-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "example.py",
+            "example.py.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "script-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "script-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pylock.toml"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "pylock-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "pylock-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-dependency-groups-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-dependency-groups-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        }
+      ]
+    },
+    {
+      "version": "0.7.0",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": 2,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "transitive": {
+          "hosted": "pass",
+          "vendored": "pass"
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-3",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "pylock-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "pylock-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "example.py",
+            "example.py.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "script-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "script-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pylock.toml"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "pylock-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "pylock-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-dependency-groups-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-dependency-groups-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        }
+      ]
+    },
+    {
+      "version": "0.7.22",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": 2,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "transitive": {
+          "hosted": "pass",
+          "vendored": "pass"
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-3",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "pylock-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "pylock-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "example.py",
+            "example.py.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "script-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "script-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pylock.toml"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "pylock-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "pylock-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-dependency-groups-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-dependency-groups-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        }
+      ]
+    },
+    {
+      "version": "0.8.0",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": 2,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "transitive": {
+          "hosted": "pass",
+          "vendored": "pass"
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-3",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "pylock-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "pylock-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "example.py",
+            "example.py.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "script-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "script-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pylock.toml"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "pylock-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "pylock-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-dependency-groups-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-dependency-groups-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        }
+      ]
+    },
+    {
+      "version": "0.8.3",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": 2,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "transitive": {
+          "hosted": "pass",
+          "vendored": "pass"
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-3",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "pylock-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "pylock-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "example.py",
+            "example.py.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "script-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "script-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pylock.toml"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "pylock-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "pylock-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-dependency-groups-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-dependency-groups-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        }
+      ]
+    },
+    {
+      "version": "0.8.4",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": 3,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "transitive": {
+          "hosted": "pass",
+          "vendored": "pass"
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-3",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "pylock-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "pylock-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "example.py",
+            "example.py.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "script-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "script-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pylock.toml"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "pylock-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "pylock-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-dependency-groups-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-dependency-groups-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        }
+      ]
+    },
+    {
+      "version": "0.8.24",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": 3,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "transitive": {
+          "hosted": "pass",
+          "vendored": "pass"
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-3",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "pylock-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "pylock-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "example.py",
+            "example.py.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "script-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "script-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pylock.toml"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "pylock-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "pylock-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-dependency-groups-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-dependency-groups-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        }
+      ]
+    },
+    {
+      "version": "0.9.0",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": 3,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "transitive": {
+          "hosted": "pass",
+          "vendored": "pass"
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-3",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "pylock-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "pylock-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "example.py",
+            "example.py.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "script-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "script-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pylock.toml"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "pylock-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "pylock-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-dependency-groups-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-dependency-groups-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        }
+      ]
+    },
+    {
+      "version": "0.9.30",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": 3,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "transitive": {
+          "hosted": "pass",
+          "vendored": "pass"
+        }
+      },
+      "observations": [
+        {
+          "command": "lock",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-3",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "requirements.txt"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "requirements-plain-hosted-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-plain-variant-2",
+          "exitCode": 0
+        },
+        {
+          "command": "requirements-plain-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "requirements-plain-vendored-pip-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "pylock-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "pylock-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-hosted",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "example.py",
+            "example.py.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "script-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-lock-vendored",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "script-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pylock.toml"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "pylock-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "pylock-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-dependency-groups-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-dependency-groups-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        }
+      ]
+    },
+    {
+      "version": "0.10.0",
+      "lockSchema": "package",
+      "lockVersion": 1,
+      "lockRevision": 3,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "transitive": {
+          "hosted": "pass",
+          "vendored": "pass"
+        }
+      },
       "observations": [
         {
           "command": "lock",
-          "exitCode": 2,
-          "diagnostic": "error: unrecognized subcommand 'lock'\n\n  tip: a similar subcommand exists: 'uv pip compile'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "project-hosted-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-export-pylock.toml",
+          "exitCode": 0
+        },
+        {
+          "command": "project-hosted-lock-sync-variant-3",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "project-vendored-export-requirements-txt",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-export-pylock.toml",
+          "exitCode": 0
+        },
+        {
+          "command": "project-vendored-lock-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
           "command": "requirements-hosted-socket-patch",
@@ -622,8 +17863,9 @@
         },
         {
           "command": "requirements-vendored-pip-sync",
-          "exitCode": 2,
-          "diagnostic": "error: Unexpected '.', expected '-c', '-e', '-r' or the start of a requirement in `requirements.txt` at position 144\n"
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
           "command": "compile-plain",
@@ -659,44 +17901,178 @@
         },
         {
           "command": "requirements-plain-vendored-pip-sync",
-          "exitCode": 2,
-          "diagnostic": "error: Unexpected '.', expected '-c', '-e', '-r' or the start of a requirement in `requirements.txt` at position 126\n"
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "pylock-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "requirements-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "pylock-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
           "command": "script-lock-hosted",
-          "exitCode": 2,
-          "diagnostic": "error: unrecognized subcommand 'lock'\n\n  tip: a similar subcommand exists: 'uv pip compile'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "example.py",
+            "example.py.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "script-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
           "command": "script-lock-vendored",
-          "exitCode": 2,
-          "diagnostic": "error: unrecognized subcommand 'lock'\n\n  tip: a similar subcommand exists: 'uv pip compile'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "script-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pylock.toml"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "pylock-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "pylock-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-hosted-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "project-vendored-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-hosted-unfrozen-install",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "script-vendored-locked-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "compile-pylock-hosted",
+          "command": "script-vendored-unfrozen-install",
           "exitCode": 0,
-          "formatSupported": false
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "compile-pylock-vendored",
+          "command": "variant-tool-uv-dev-hosted-lock",
           "exitCode": 0,
-          "formatSupported": false
-        }
-      ]
-    },
-    {
-      "version": "0.1.45",
-      "lockSchema": "distribution",
-      "lockVersion": 1,
-      "lockRevision": null,
-      "observations": [
-        {
-          "command": "lock",
-          "exitCode": 0
+          "formatSupported": true
         },
         {
-          "command": "project-hosted-socket-patch",
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "rewrittenFiles": [
             "pyproject.toml",
             "uv.lock"
@@ -705,147 +18081,144 @@
           "warnings": []
         },
         {
-          "command": "project-hosted-export-requirements-txt",
-          "exitCode": 2,
-          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-hosted-export-pylock.toml",
-          "exitCode": 2,
-          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-hosted-lock-sync",
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-socket-patch",
-          "exitCode": 1,
-          "vendorSummary": {
-            "applied": 0,
-            "failed": 1
-          },
-          "vendorErrors": [
-            {
-              "action": "failed",
-              "purl": "pkg:pypi/urllib3@1.26.18?artifact_id=py2-py3-none-any-whl",
-              "errorCode": "pypi_uv_legacy_lock_unsupported",
-              "error": "uv 0.1 lockfiles require absolute file URLs; upgrade to uv >=0.2 for portable native vendoring, or use a requirements.txt installation"
-            }
-          ]
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
         },
         {
-          "command": "requirements-hosted-socket-patch",
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
           "exitCode": 0,
-          "rewrittenFiles": [
-            "requirements.txt"
-          ],
-          "redirected": 1,
-          "warnings": []
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
         },
         {
-          "command": "requirements-hosted-pip-sync",
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-vendored-socket-patch",
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
           "exitCode": 0,
-          "vendorSummary": {
-            "applied": 1,
-            "failed": 0
-          },
-          "vendorErrors": []
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "requirements-vendored-pip-sync",
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-plain",
-          "exitCode": 0
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
         },
         {
-          "command": "requirements-plain-hosted-socket-patch",
+          "command": "variant-dependency-groups-hosted-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "rewrittenFiles": [
-            "requirements.txt"
+            "pyproject.toml",
+            "uv.lock"
           ],
           "redirected": 1,
           "warnings": []
         },
         {
-          "command": "requirements-plain-hosted-pip-sync",
+          "command": "variant-dependency-groups-hosted-frozen-sync",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-plain-variant-2",
-          "exitCode": 0
-        },
-        {
-          "command": "requirements-plain-vendored-socket-patch",
+          "command": "variant-dependency-groups-hosted-locked-sync",
           "exitCode": 0,
-          "vendorSummary": {
-            "applied": 1,
-            "failed": 0
-          },
-          "vendorErrors": []
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "requirements-plain-vendored-pip-sync",
+          "command": "variant-dependency-groups-hosted-plain-sync",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-lock-hosted",
-          "exitCode": 2,
-          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
         },
         {
-          "command": "script-lock-vendored",
-          "exitCode": 2,
-          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+          "command": "variant-dependency-groups-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
         },
         {
-          "command": "compile-pylock-hosted",
+          "command": "variant-dependency-groups-vendored-frozen-sync",
           "exitCode": 0,
-          "formatSupported": false
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "compile-pylock-vendored",
+          "command": "variant-dependency-groups-vendored-locked-sync",
           "exitCode": 0,
-          "formatSupported": false
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-hosted-unfrozen-install",
+          "command": "variant-dependency-groups-vendored-plain-sync",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
-        }
-      ]
-    },
-    {
-      "version": "0.2.37",
-      "lockSchema": "package",
-      "lockVersion": 1,
-      "lockRevision": null,
-      "observations": [
+        },
         {
-          "command": "lock",
-          "exitCode": 0
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
         },
         {
-          "command": "project-hosted-socket-patch",
+          "command": "variant-extras-duplicate-hosted-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "rewrittenFiles": [
             "pyproject.toml",
             "uv.lock"
@@ -854,25 +18227,35 @@
           "warnings": []
         },
         {
-          "command": "project-hosted-export-requirements-txt",
-          "exitCode": 2,
-          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-hosted-export-pylock.toml",
-          "exitCode": 2,
-          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-hosted-lock-sync-variant-2",
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-socket-patch",
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "vendorSummary": {
             "applied": 1,
             "failed": 0
@@ -880,39 +18263,72 @@
           "vendorErrors": []
         },
         {
-          "command": "project-vendored-export-requirements-txt",
-          "exitCode": 2,
-          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-vendored-export-pylock.toml",
-          "exitCode": 2,
-          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-vendored-lock-sync",
-          "exitCode": 2,
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
           "lockUnchanged": true,
-          "diagnostic": "warning: `uv sync` is experimental and may change without warning\nUsing Python 3.9.6 interpreter at: /Applications/Xcode.app/Contents/Developer/usr/bin/python3\nCreating virtualenv at: .venv\nerror: Failed to prepare distributions\n  Caused by: Failed to fetch wheel: socket-uv-patch-fixture @ file://<output>/matrix/0.2.37/project-vendored\n  Caused by: Failed to install requirements from setup.py build (resolve)\n  Caused by: No solution found when resolving: setuptools>=40.8.0\n  Caused by: Because setuptools was not found in the cache and you require setuptools>=40.8.0, we can conclude that your requirements are unsatisfiable.\n\nhint: Packages were unavailable because the network was disabled\n"
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "requirements-hosted-socket-patch",
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-hosted-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "rewrittenFiles": [
-            "requirements.txt"
+            "pyproject.toml",
+            "uv.lock"
           ],
           "redirected": 1,
           "warnings": []
         },
         {
-          "command": "requirements-hosted-pip-sync",
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-vendored-socket-patch",
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "vendorSummary": {
             "applied": 1,
             "failed": 0
@@ -920,108 +18336,128 @@
           "vendorErrors": []
         },
         {
-          "command": "requirements-vendored-pip-sync",
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-plain",
-          "exitCode": 0
-        },
-        {
-          "command": "requirements-plain-hosted-socket-patch",
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
           "exitCode": 0,
-          "rewrittenFiles": [
-            "requirements.txt"
-          ],
-          "redirected": 1,
-          "warnings": []
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "requirements-plain-hosted-pip-sync",
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-plain-variant-2",
-          "exitCode": 0
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
         },
         {
-          "command": "requirements-plain-vendored-socket-patch",
+          "command": "variant-transitive-hosted-socket-patch",
           "exitCode": 0,
-          "vendorSummary": {
-            "applied": 1,
-            "failed": 0
-          },
-          "vendorErrors": []
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
         },
         {
-          "command": "requirements-plain-vendored-pip-sync",
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-frozen-sync-root-build-networked",
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-lock-hosted",
-          "exitCode": 2,
-          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
-        },
-        {
-          "command": "script-lock-vendored",
-          "exitCode": 2,
-          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
-        },
-        {
-          "command": "compile-pylock-hosted",
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
           "exitCode": 0,
-          "formatSupported": false
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "compile-pylock-vendored",
+          "command": "variant-transitive-vendored-lock",
           "exitCode": 0,
-          "formatSupported": false
+          "formatSupported": true
         },
         {
-          "command": "project-hosted-locked-install",
+          "command": "variant-transitive-vendored-socket-patch",
           "exitCode": 0,
-          "lockUnchanged": true,
-          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
-          "installedPatch": true
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
         },
         {
-          "command": "project-hosted-unfrozen-install",
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-locked-install",
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-unfrozen-install",
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         }
       ]
     },
     {
-      "version": "0.3.5",
+      "version": "0.10.12",
       "lockSchema": "package",
       "lockVersion": 1,
-      "lockRevision": null,
+      "lockRevision": 3,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "transitive": {
+          "hosted": "pass",
+          "vendored": "pass"
+        }
+      },
       "observations": [
         {
           "command": "lock",
@@ -1039,13 +18475,11 @@
         },
         {
           "command": "project-hosted-export-requirements-txt",
-          "exitCode": 2,
-          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+          "exitCode": 0
         },
         {
           "command": "project-hosted-export-pylock.toml",
-          "exitCode": 2,
-          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+          "exitCode": 0
         },
         {
           "command": "project-hosted-lock-sync-variant-3",
@@ -1065,13 +18499,11 @@
         },
         {
           "command": "project-vendored-export-requirements-txt",
-          "exitCode": 2,
-          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+          "exitCode": 0
         },
         {
           "command": "project-vendored-export-pylock.toml",
-          "exitCode": 2,
-          "diagnostic": "error: unrecognized subcommand 'export'\n\nUsage: uv [OPTIONS] <COMMAND>\n\nFor more information, try '--help'.\n"
+          "exitCode": 0
         },
         {
           "command": "project-vendored-lock-sync-variant-2",
@@ -1149,91 +18581,56 @@
           "installedPatch": true
         },
         {
-          "command": "script-lock-hosted",
-          "exitCode": 2,
-          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
-        },
-        {
-          "command": "script-lock-vendored",
-          "exitCode": 2,
-          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
-        },
-        {
-          "command": "compile-pylock-hosted",
-          "exitCode": 0,
-          "formatSupported": false
-        },
-        {
-          "command": "compile-pylock-vendored",
-          "exitCode": 0,
-          "formatSupported": false
-        },
-        {
-          "command": "project-hosted-locked-install-variant-2",
+          "command": "requirements-hosted-export-sync",
           "exitCode": 0,
-          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-hosted-unfrozen-install-variant-2",
+          "command": "pylock-hosted-export-sync",
           "exitCode": 0,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-locked-install-variant-2",
+          "command": "requirements-vendored-export-sync",
           "exitCode": 0,
-          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-unfrozen-install-variant-2",
+          "command": "pylock-vendored-export-sync",
           "exitCode": 0,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
-        }
-      ]
-    },
-    {
-      "version": "0.4.30",
-      "lockSchema": "package",
-      "lockVersion": 1,
-      "lockRevision": null,
-      "observations": [
+        },
         {
-          "command": "lock",
+          "command": "script-lock-hosted",
           "exitCode": 0
         },
         {
-          "command": "project-hosted-socket-patch",
+          "command": "script-direct-hosted-socket-patch",
           "exitCode": 0,
           "rewrittenFiles": [
-            "pyproject.toml",
-            "uv.lock"
+            "example.py",
+            "example.py.lock"
           ],
           "redirected": 1,
           "warnings": []
         },
         {
-          "command": "project-hosted-export-requirements-txt",
-          "exitCode": 0
-        },
-        {
-          "command": "project-hosted-export-pylock.toml",
-          "exitCode": 2,
-          "diagnostic": "error: invalid value 'pylock.toml' for '--format <FORMAT>'\n  [possible values: requirements-txt]\n\nFor more information, try '--help'.\n"
-        },
-        {
-          "command": "project-hosted-lock-sync-variant-3",
+          "command": "script-direct-hosted-install",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-socket-patch",
+          "command": "script-lock-vendored",
+          "exitCode": 0
+        },
+        {
+          "command": "script-direct-vendored-socket-patch",
           "exitCode": 0,
           "vendorSummary": {
             "applied": 1,
@@ -1242,38 +18639,40 @@
           "vendorErrors": []
         },
         {
-          "command": "project-vendored-export-requirements-txt",
-          "exitCode": 0
-        },
-        {
-          "command": "project-vendored-export-pylock.toml",
-          "exitCode": 2,
-          "diagnostic": "error: invalid value 'pylock.toml' for '--format <FORMAT>'\n  [possible values: requirements-txt]\n\nFor more information, try '--help'.\n"
-        },
-        {
-          "command": "project-vendored-lock-sync-variant-2",
+          "command": "script-direct-vendored-install",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-hosted-socket-patch",
+          "command": "compile-pylock-hosted",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-hosted-socket-patch",
           "exitCode": 0,
           "rewrittenFiles": [
-            "requirements.txt"
+            "pylock.toml"
           ],
           "redirected": 1,
           "warnings": []
         },
         {
-          "command": "requirements-hosted-pip-sync",
+          "command": "pylock-direct-hosted-install",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-vendored-socket-patch",
+          "command": "compile-pylock-vendored",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-vendored-socket-patch",
           "exitCode": 0,
           "vendorSummary": {
             "applied": 1,
@@ -1282,122 +18681,146 @@
           "vendorErrors": []
         },
         {
-          "command": "requirements-vendored-pip-sync",
+          "command": "pylock-direct-vendored-install",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-plain",
-          "exitCode": 0
+          "command": "project-hosted-locked-install-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "requirements-plain-hosted-socket-patch",
+          "command": "project-hosted-unfrozen-install-variant-2",
           "exitCode": 0,
-          "rewrittenFiles": [
-            "requirements.txt"
-          ],
-          "redirected": 1,
-          "warnings": []
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "requirements-plain-hosted-pip-sync",
+          "command": "project-vendored-locked-install-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-plain-variant-2",
-          "exitCode": 0
+          "command": "project-vendored-unfrozen-install-variant-2",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "requirements-plain-vendored-socket-patch",
+          "command": "script-hosted-locked-install",
           "exitCode": 0,
-          "vendorSummary": {
-            "applied": 1,
-            "failed": 0
-          },
-          "vendorErrors": []
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "requirements-plain-vendored-pip-sync",
+          "command": "script-hosted-unfrozen-install",
           "exitCode": 0,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-hosted-export-sync",
+          "command": "script-vendored-locked-install",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-vendored-export-sync",
+          "command": "script-vendored-unfrozen-install",
           "exitCode": 0,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-lock-hosted",
-          "exitCode": 2,
-          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
         },
         {
-          "command": "script-lock-vendored",
-          "exitCode": 2,
-          "diagnostic": "error: unexpected argument '--script' found\n\nUsage: uv lock [OPTIONS]\n\nFor more information, try '--help'.\n"
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
         },
         {
-          "command": "compile-pylock-hosted",
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
           "exitCode": 0,
-          "formatSupported": false
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "compile-pylock-vendored",
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
           "exitCode": 0,
-          "formatSupported": false
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-hosted-locked-install-variant-2",
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-hosted-unfrozen-install-variant-2",
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-locked-install-variant-2",
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-unfrozen-install-variant-2",
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
-        }
-      ]
-    },
-    {
-      "version": "0.5.31",
-      "lockSchema": "package",
-      "lockVersion": 1,
-      "lockRevision": null,
-      "observations": [
+        },
         {
-          "command": "lock",
-          "exitCode": 0
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
         },
         {
-          "command": "project-hosted-socket-patch",
+          "command": "variant-dependency-groups-hosted-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "rewrittenFiles": [
             "pyproject.toml",
             "uv.lock"
@@ -1406,24 +18829,35 @@
           "warnings": []
         },
         {
-          "command": "project-hosted-export-requirements-txt",
-          "exitCode": 0
+          "command": "variant-dependency-groups-hosted-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-hosted-export-pylock.toml",
-          "exitCode": 2,
-          "diagnostic": "error: invalid value 'pylock.toml' for '--format <FORMAT>'\n  [possible values: requirements-txt]\n\nFor more information, try '--help'.\n"
+          "command": "variant-dependency-groups-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-hosted-lock-sync-variant-3",
+          "command": "variant-dependency-groups-hosted-plain-sync",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-socket-patch",
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "vendorSummary": {
             "applied": 1,
             "failed": 0
@@ -1431,77 +18865,72 @@
           "vendorErrors": []
         },
         {
-          "command": "project-vendored-export-requirements-txt",
-          "exitCode": 0
+          "command": "variant-dependency-groups-vendored-frozen-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-vendored-export-pylock.toml",
-          "exitCode": 2,
-          "diagnostic": "error: invalid value 'pylock.toml' for '--format <FORMAT>'\n  [possible values: requirements-txt]\n\nFor more information, try '--help'.\n"
+          "command": "variant-dependency-groups-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-vendored-lock-sync-variant-2",
+          "command": "variant-dependency-groups-vendored-plain-sync",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-hosted-socket-patch",
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "rewrittenFiles": [
-            "requirements.txt"
+            "pyproject.toml",
+            "uv.lock"
           ],
           "redirected": 1,
           "warnings": []
         },
         {
-          "command": "requirements-hosted-pip-sync",
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-vendored-socket-patch",
-          "exitCode": 0,
-          "vendorSummary": {
-            "applied": 1,
-            "failed": 0
-          },
-          "vendorErrors": []
-        },
-        {
-          "command": "requirements-vendored-pip-sync",
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-plain",
-          "exitCode": 0
-        },
-        {
-          "command": "requirements-plain-hosted-socket-patch",
-          "exitCode": 0,
-          "rewrittenFiles": [
-            "requirements.txt"
-          ],
-          "redirected": 1,
-          "warnings": []
-        },
-        {
-          "command": "requirements-plain-hosted-pip-sync",
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-plain-variant-2",
-          "exitCode": 0
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
         },
         {
-          "command": "requirements-plain-vendored-socket-patch",
+          "command": "variant-extras-duplicate-vendored-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "vendorSummary": {
             "applied": 1,
             "failed": 0
@@ -1509,51 +18938,72 @@
           "vendorErrors": []
         },
         {
-          "command": "requirements-plain-vendored-pip-sync",
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-hosted-export-sync",
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-vendored-export-sync",
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-lock-hosted",
-          "exitCode": 0
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
         },
         {
-          "command": "script-direct-hosted-socket-patch",
+          "command": "variant-constraints-hosted-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "rewrittenFiles": [
-            "example.py",
-            "example.py.lock"
+            "pyproject.toml",
+            "uv.lock"
           ],
           "redirected": 1,
           "warnings": []
         },
         {
-          "command": "script-direct-hosted-install",
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-lock-vendored",
-          "exitCode": 0
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "script-direct-vendored-socket-patch",
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-constraints-vendored-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "vendorSummary": {
             "applied": 1,
             "failed": 0
@@ -1561,81 +19011,128 @@
           "vendorErrors": []
         },
         {
-          "command": "script-direct-vendored-install",
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-pylock-hosted",
-          "exitCode": 0,
-          "formatSupported": false
-        },
-        {
-          "command": "compile-pylock-vendored",
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
           "exitCode": 0,
-          "formatSupported": false
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-hosted-locked-install-variant-2",
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-hosted-unfrozen-install-variant-2",
+          "command": "variant-transitive-hosted-lock",
           "exitCode": 0,
-          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
-          "installedPatch": true
+          "formatSupported": true
         },
         {
-          "command": "project-vendored-locked-install-variant-2",
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-unfrozen-install-variant-2",
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-hosted-locked-install",
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-hosted-unfrozen-install",
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-vendored-locked-install",
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-vendored-unfrozen-install",
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         }
       ]
     },
     {
-      "version": "0.6.0",
+      "version": "0.11.0",
       "lockSchema": "package",
       "lockVersion": 1,
-      "lockRevision": 1,
+      "lockRevision": 3,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "transitive": {
+          "hosted": "pass",
+          "vendored": "pass"
+        }
+      },
       "observations": [
         {
           "command": "lock",
@@ -1657,8 +19154,7 @@
         },
         {
           "command": "project-hosted-export-pylock.toml",
-          "exitCode": 2,
-          "diagnostic": "error: invalid value 'pylock.toml' for '--format <FORMAT>'\n  [possible values: requirements-txt]\n\nFor more information, try '--help'.\n"
+          "exitCode": 0
         },
         {
           "command": "project-hosted-lock-sync-variant-3",
@@ -1682,8 +19178,7 @@
         },
         {
           "command": "project-vendored-export-pylock.toml",
-          "exitCode": 2,
-          "diagnostic": "error: invalid value 'pylock.toml' for '--format <FORMAT>'\n  [possible values: requirements-txt]\n\nFor more information, try '--help'.\n"
+          "exitCode": 0
         },
         {
           "command": "project-vendored-lock-sync-variant-2",
@@ -1766,12 +19261,24 @@
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
+        {
+          "command": "pylock-hosted-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
         {
           "command": "requirements-vendored-export-sync",
           "exitCode": 0,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
+        {
+          "command": "pylock-vendored-export-sync",
+          "exitCode": 0,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
         {
           "command": "script-lock-hosted",
           "exitCode": 0
@@ -1816,12 +19323,44 @@
         {
           "command": "compile-pylock-hosted",
           "exitCode": 0,
-          "formatSupported": false
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-hosted-socket-patch",
+          "exitCode": 0,
+          "rewrittenFiles": [
+            "pylock.toml"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "pylock-direct-hosted-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
           "command": "compile-pylock-vendored",
           "exitCode": 0,
-          "formatSupported": false
+          "formatSupported": true
+        },
+        {
+          "command": "pylock-direct-vendored-socket-patch",
+          "exitCode": 0,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "pylock-direct-vendored-install",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
           "command": "project-hosted-locked-install-variant-2",
@@ -1874,22 +19413,16 @@
           "exitCode": 0,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
-        }
-      ]
-    },
-    {
-      "version": "0.6.17",
-      "lockSchema": "package",
-      "lockVersion": 1,
-      "lockRevision": 2,
-      "observations": [
+        },
         {
-          "command": "lock",
-          "exitCode": 0
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
         },
         {
-          "command": "project-hosted-socket-patch",
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "rewrittenFiles": [
             "pyproject.toml",
             "uv.lock"
@@ -1898,23 +19431,35 @@
           "warnings": []
         },
         {
-          "command": "project-hosted-export-requirements-txt",
-          "exitCode": 0
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-hosted-export-pylock.toml",
-          "exitCode": 0
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-hosted-lock-sync-variant-3",
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-socket-patch",
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "vendorSummary": {
             "applied": 1,
             "failed": 0
@@ -1922,76 +19467,72 @@
           "vendorErrors": []
         },
         {
-          "command": "project-vendored-export-requirements-txt",
-          "exitCode": 0
-        },
-        {
-          "command": "project-vendored-export-pylock.toml",
-          "exitCode": 0
-        },
-        {
-          "command": "project-vendored-lock-sync-variant-2",
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-hosted-socket-patch",
-          "exitCode": 0,
-          "rewrittenFiles": [
-            "requirements.txt"
-          ],
-          "redirected": 1,
-          "warnings": []
-        },
-        {
-          "command": "requirements-hosted-pip-sync",
-          "exitCode": 0,
-          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
-          "installedPatch": true
-        },
-        {
-          "command": "requirements-vendored-socket-patch",
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
           "exitCode": 0,
-          "vendorSummary": {
-            "applied": 1,
-            "failed": 0
-          },
-          "vendorErrors": []
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "requirements-vendored-pip-sync",
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-plain",
-          "exitCode": 0
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
         },
         {
-          "command": "requirements-plain-hosted-socket-patch",
+          "command": "variant-dependency-groups-hosted-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "rewrittenFiles": [
-            "requirements.txt"
+            "pyproject.toml",
+            "uv.lock"
           ],
           "redirected": 1,
           "warnings": []
         },
         {
-          "command": "requirements-plain-hosted-pip-sync",
+          "command": "variant-dependency-groups-hosted-frozen-sync",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-plain-variant-2",
-          "exitCode": 0
+          "command": "variant-dependency-groups-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "requirements-plain-vendored-socket-patch",
+          "command": "variant-dependency-groups-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "vendorSummary": {
             "applied": 1,
             "failed": 0
@@ -1999,63 +19540,72 @@
           "vendorErrors": []
         },
         {
-          "command": "requirements-plain-vendored-pip-sync",
+          "command": "variant-dependency-groups-vendored-frozen-sync",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-hosted-export-sync",
+          "command": "variant-dependency-groups-vendored-locked-sync",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "pylock-hosted-export-sync",
+          "command": "variant-dependency-groups-vendored-plain-sync",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-vendored-export-sync",
+          "command": "variant-extras-duplicate-hosted-lock",
           "exitCode": 0,
-          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
-          "installedPatch": true
+          "formatSupported": true
         },
         {
-          "command": "pylock-vendored-export-sync",
+          "command": "variant-extras-duplicate-hosted-socket-patch",
           "exitCode": 0,
-          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
-          "installedPatch": true
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
         },
         {
-          "command": "script-lock-hosted",
-          "exitCode": 0
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "script-direct-hosted-socket-patch",
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
           "exitCode": 0,
-          "rewrittenFiles": [
-            "example.py",
-            "example.py.lock"
-          ],
-          "redirected": 1,
-          "warnings": []
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "script-direct-hosted-install",
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-lock-vendored",
-          "exitCode": 0
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
         },
         {
-          "command": "script-direct-vendored-socket-patch",
+          "command": "variant-extras-duplicate-vendored-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "vendorSummary": {
             "applied": 1,
             "failed": 0
@@ -2063,41 +19613,72 @@
           "vendorErrors": []
         },
         {
-          "command": "script-direct-vendored-install",
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-pylock-hosted",
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
           "exitCode": 0,
           "formatSupported": true
         },
         {
-          "command": "pylock-direct-hosted-socket-patch",
+          "command": "variant-constraints-hosted-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "rewrittenFiles": [
-            "pylock.toml"
+            "pyproject.toml",
+            "uv.lock"
           ],
           "redirected": 1,
           "warnings": []
         },
         {
-          "command": "pylock-direct-hosted-install",
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-pylock-vendored",
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
           "exitCode": 0,
           "formatSupported": true
         },
         {
-          "command": "pylock-direct-vendored-socket-patch",
+          "command": "variant-constraints-vendored-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "vendorSummary": {
             "applied": 1,
             "failed": 0
@@ -2105,71 +19686,128 @@
           "vendorErrors": []
         },
         {
-          "command": "pylock-direct-vendored-install",
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-hosted-locked-install-variant-2",
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-hosted-unfrozen-install-variant-2",
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-locked-install-variant-2",
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-unfrozen-install-variant-2",
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-hosted-locked-install",
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-hosted-unfrozen-install",
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-vendored-locked-install",
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-vendored-unfrozen-install",
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         }
       ]
     },
     {
-      "version": "0.7.22",
+      "version": "0.11.33",
       "lockSchema": "package",
       "lockVersion": 1,
-      "lockRevision": 2,
+      "lockRevision": 3,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "transitive": {
+          "hosted": "pass",
+          "vendored": "pass"
+        }
+      },
       "observations": [
         {
           "command": "lock",
@@ -2450,22 +20088,16 @@
           "exitCode": 0,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
-        }
-      ]
-    },
-    {
-      "version": "0.8.24",
-      "lockSchema": "package",
-      "lockVersion": 1,
-      "lockRevision": 3,
-      "observations": [
+        },
         {
-          "command": "lock",
-          "exitCode": 0
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
         },
         {
-          "command": "project-hosted-socket-patch",
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "rewrittenFiles": [
             "pyproject.toml",
             "uv.lock"
@@ -2474,23 +20106,35 @@
           "warnings": []
         },
         {
-          "command": "project-hosted-export-requirements-txt",
-          "exitCode": 0
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-hosted-export-pylock.toml",
-          "exitCode": 0
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-hosted-lock-sync-variant-3",
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-socket-patch",
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "vendorSummary": {
             "applied": 1,
             "failed": 0
@@ -2498,76 +20142,72 @@
           "vendorErrors": []
         },
         {
-          "command": "project-vendored-export-requirements-txt",
-          "exitCode": 0
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-vendored-export-pylock.toml",
-          "exitCode": 0
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-vendored-lock-sync-variant-2",
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-hosted-socket-patch",
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "rewrittenFiles": [
-            "requirements.txt"
+            "pyproject.toml",
+            "uv.lock"
           ],
           "redirected": 1,
           "warnings": []
         },
         {
-          "command": "requirements-hosted-pip-sync",
+          "command": "variant-dependency-groups-hosted-frozen-sync",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-vendored-socket-patch",
-          "exitCode": 0,
-          "vendorSummary": {
-            "applied": 1,
-            "failed": 0
-          },
-          "vendorErrors": []
-        },
-        {
-          "command": "requirements-vendored-pip-sync",
+          "command": "variant-dependency-groups-hosted-locked-sync",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-plain",
-          "exitCode": 0
-        },
-        {
-          "command": "requirements-plain-hosted-socket-patch",
-          "exitCode": 0,
-          "rewrittenFiles": [
-            "requirements.txt"
-          ],
-          "redirected": 1,
-          "warnings": []
-        },
-        {
-          "command": "requirements-plain-hosted-pip-sync",
+          "command": "variant-dependency-groups-hosted-plain-sync",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-plain-variant-2",
-          "exitCode": 0
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
         },
         {
-          "command": "requirements-plain-vendored-socket-patch",
+          "command": "variant-dependency-groups-vendored-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "vendorSummary": {
             "applied": 1,
             "failed": 0
@@ -2575,105 +20215,145 @@
           "vendorErrors": []
         },
         {
-          "command": "requirements-plain-vendored-pip-sync",
+          "command": "variant-dependency-groups-vendored-frozen-sync",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-hosted-export-sync",
+          "command": "variant-dependency-groups-vendored-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-plain-sync",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "pylock-hosted-export-sync",
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-vendored-export-sync",
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "pylock-vendored-export-sync",
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-lock-hosted",
-          "exitCode": 0
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
         },
         {
-          "command": "script-direct-hosted-socket-patch",
+          "command": "variant-extras-duplicate-vendored-socket-patch",
           "exitCode": 0,
-          "rewrittenFiles": [
-            "example.py",
-            "example.py.lock"
-          ],
-          "redirected": 1,
-          "warnings": []
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
         },
         {
-          "command": "script-direct-hosted-install",
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-lock-vendored",
-          "exitCode": 0
-        },
-        {
-          "command": "script-direct-vendored-socket-patch",
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
           "exitCode": 0,
-          "vendorSummary": {
-            "applied": 1,
-            "failed": 0
-          },
-          "vendorErrors": []
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "script-direct-vendored-install",
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-pylock-hosted",
+          "command": "variant-constraints-hosted-lock",
           "exitCode": 0,
           "formatSupported": true
         },
         {
-          "command": "pylock-direct-hosted-socket-patch",
+          "command": "variant-constraints-hosted-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "rewrittenFiles": [
-            "pylock.toml"
+            "pyproject.toml",
+            "uv.lock"
           ],
           "redirected": 1,
           "warnings": []
         },
         {
-          "command": "pylock-direct-hosted-install",
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-pylock-vendored",
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
           "exitCode": 0,
           "formatSupported": true
         },
         {
-          "command": "pylock-direct-vendored-socket-patch",
+          "command": "variant-constraints-vendored-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "vendorSummary": {
             "applied": 1,
             "failed": 0
@@ -2681,71 +20361,128 @@
           "vendorErrors": []
         },
         {
-          "command": "pylock-direct-vendored-install",
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-hosted-locked-install-variant-2",
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-hosted-unfrozen-install-variant-2",
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-locked-install-variant-2",
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-unfrozen-install-variant-2",
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-hosted-locked-install",
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-hosted-unfrozen-install",
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-vendored-locked-install",
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-vendored-unfrozen-install",
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         }
       ]
     },
     {
-      "version": "0.9.30",
+      "version": "0.12.0",
       "lockSchema": "package",
       "lockVersion": 1,
       "lockRevision": 3,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "transitive": {
+          "hosted": "pass",
+          "vendored": "pass"
+        }
+      },
       "observations": [
         {
           "command": "lock",
@@ -3026,22 +20763,16 @@
           "exitCode": 0,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
-        }
-      ]
-    },
-    {
-      "version": "0.10.12",
-      "lockSchema": "package",
-      "lockVersion": 1,
-      "lockRevision": 3,
-      "observations": [
+        },
         {
-          "command": "lock",
-          "exitCode": 0
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
         },
         {
-          "command": "project-hosted-socket-patch",
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "rewrittenFiles": [
             "pyproject.toml",
             "uv.lock"
@@ -3050,23 +20781,35 @@
           "warnings": []
         },
         {
-          "command": "project-hosted-export-requirements-txt",
-          "exitCode": 0
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-hosted-export-pylock.toml",
-          "exitCode": 0
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-hosted-lock-sync-variant-3",
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-socket-patch",
+          "command": "variant-tool-uv-dev-vendored-lock",
           "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
           "vendorSummary": {
             "applied": 1,
             "failed": 0
@@ -3074,38 +20817,72 @@
           "vendorErrors": []
         },
         {
-          "command": "project-vendored-export-requirements-txt",
-          "exitCode": 0
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-vendored-export-pylock.toml",
-          "exitCode": 0
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-vendored-lock-sync-variant-2",
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-hosted-socket-patch",
+          "command": "variant-dependency-groups-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "rewrittenFiles": [
-            "requirements.txt"
+            "pyproject.toml",
+            "uv.lock"
           ],
           "redirected": 1,
           "warnings": []
         },
         {
-          "command": "requirements-hosted-pip-sync",
+          "command": "variant-dependency-groups-hosted-frozen-sync",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-vendored-socket-patch",
+          "command": "variant-dependency-groups-hosted-locked-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-plain-sync",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-lock",
           "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
           "vendorSummary": {
             "applied": 1,
             "failed": 0
@@ -3113,143 +20890,145 @@
           "vendorErrors": []
         },
         {
-          "command": "requirements-vendored-pip-sync",
+          "command": "variant-dependency-groups-vendored-frozen-sync",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-plain",
-          "exitCode": 0
-        },
-        {
-          "command": "requirements-plain-hosted-socket-patch",
+          "command": "variant-dependency-groups-vendored-locked-sync",
           "exitCode": 0,
-          "rewrittenFiles": [
-            "requirements.txt"
-          ],
-          "redirected": 1,
-          "warnings": []
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "requirements-plain-hosted-pip-sync",
+          "command": "variant-dependency-groups-vendored-plain-sync",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-plain-variant-2",
-          "exitCode": 0
+          "command": "variant-extras-duplicate-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
         },
         {
-          "command": "requirements-plain-vendored-socket-patch",
+          "command": "variant-extras-duplicate-hosted-socket-patch",
           "exitCode": 0,
-          "vendorSummary": {
-            "applied": 1,
-            "failed": 0
-          },
-          "vendorErrors": []
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
         },
         {
-          "command": "requirements-plain-vendored-pip-sync",
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-hosted-export-sync",
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "pylock-hosted-export-sync",
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-vendored-export-sync",
+          "command": "variant-extras-duplicate-vendored-lock",
           "exitCode": 0,
-          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
-          "installedPatch": true
+          "formatSupported": true
         },
         {
-          "command": "pylock-vendored-export-sync",
+          "command": "variant-extras-duplicate-vendored-socket-patch",
           "exitCode": 0,
-          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
-          "installedPatch": true
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
         },
         {
-          "command": "script-lock-hosted",
-          "exitCode": 0
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "script-direct-hosted-socket-patch",
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
           "exitCode": 0,
-          "rewrittenFiles": [
-            "example.py",
-            "example.py.lock"
-          ],
-          "redirected": 1,
-          "warnings": []
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "script-direct-hosted-install",
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-lock-vendored",
-          "exitCode": 0
+          "command": "variant-constraints-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
         },
         {
-          "command": "script-direct-vendored-socket-patch",
+          "command": "variant-constraints-hosted-socket-patch",
           "exitCode": 0,
-          "vendorSummary": {
-            "applied": 1,
-            "failed": 0
-          },
-          "vendorErrors": []
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
         },
         {
-          "command": "script-direct-vendored-install",
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-pylock-hosted",
-          "exitCode": 0,
-          "formatSupported": true
-        },
-        {
-          "command": "pylock-direct-hosted-socket-patch",
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
           "exitCode": 0,
-          "rewrittenFiles": [
-            "pylock.toml"
-          ],
-          "redirected": 1,
-          "warnings": []
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "pylock-direct-hosted-install",
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-pylock-vendored",
+          "command": "variant-constraints-vendored-lock",
           "exitCode": 0,
           "formatSupported": true
         },
         {
-          "command": "pylock-direct-vendored-socket-patch",
+          "command": "variant-constraints-vendored-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "vendorSummary": {
             "applied": 1,
             "failed": 0
@@ -3257,71 +21036,128 @@
           "vendorErrors": []
         },
         {
-          "command": "pylock-direct-vendored-install",
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-hosted-locked-install-variant-2",
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-hosted-unfrozen-install-variant-2",
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-locked-install-variant-2",
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-unfrozen-install-variant-2",
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-hosted-locked-install",
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-hosted-unfrozen-install",
+          "command": "variant-transitive-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-vendored-locked-install",
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-vendored-unfrozen-install",
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         }
       ]
     },
     {
-      "version": "0.11.33",
+      "version": "0.12.15",
       "lockSchema": "package",
       "lockVersion": 1,
       "lockRevision": 3,
+      "variants": {
+        "tool-uv-dev": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "dependency-groups": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "extras-duplicate": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "constraints": {
+          "hosted": "pass",
+          "vendored": "pass"
+        },
+        "transitive": {
+          "hosted": "pass",
+          "vendored": "pass"
+        }
+      },
       "observations": [
         {
           "command": "lock",
@@ -3602,22 +21438,16 @@
           "exitCode": 0,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
-        }
-      ]
-    },
-    {
-      "version": "0.12.13",
-      "lockSchema": "package",
-      "lockVersion": 1,
-      "lockRevision": 3,
-      "observations": [
+        },
         {
-          "command": "lock",
-          "exitCode": 0
+          "command": "variant-tool-uv-dev-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
         },
         {
-          "command": "project-hosted-socket-patch",
+          "command": "variant-tool-uv-dev-hosted-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "rewrittenFiles": [
             "pyproject.toml",
             "uv.lock"
@@ -3626,23 +21456,35 @@
           "warnings": []
         },
         {
-          "command": "project-hosted-export-requirements-txt",
-          "exitCode": 0
+          "command": "variant-tool-uv-dev-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-hosted-export-pylock.toml",
-          "exitCode": 0
+          "command": "variant-tool-uv-dev-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-hosted-lock-sync-variant-3",
+          "command": "variant-tool-uv-dev-hosted-plain-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-socket-patch",
+          "command": "variant-tool-uv-dev-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-tool-uv-dev-vendored-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "vendorSummary": {
             "applied": 1,
             "failed": 0
@@ -3650,76 +21492,72 @@
           "vendorErrors": []
         },
         {
-          "command": "project-vendored-export-requirements-txt",
-          "exitCode": 0
+          "command": "variant-tool-uv-dev-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-vendored-export-pylock.toml",
-          "exitCode": 0
+          "command": "variant-tool-uv-dev-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "project-vendored-lock-sync-variant-2",
+          "command": "variant-tool-uv-dev-vendored-plain-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-hosted-socket-patch",
+          "command": "variant-dependency-groups-hosted-lock",
           "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-dependency-groups-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
           "rewrittenFiles": [
-            "requirements.txt"
+            "pyproject.toml",
+            "uv.lock"
           ],
           "redirected": 1,
           "warnings": []
         },
         {
-          "command": "requirements-hosted-pip-sync",
+          "command": "variant-dependency-groups-hosted-frozen-sync",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-vendored-socket-patch",
-          "exitCode": 0,
-          "vendorSummary": {
-            "applied": 1,
-            "failed": 0
-          },
-          "vendorErrors": []
-        },
-        {
-          "command": "requirements-vendored-pip-sync",
+          "command": "variant-dependency-groups-hosted-locked-sync",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-plain",
-          "exitCode": 0
-        },
-        {
-          "command": "requirements-plain-hosted-socket-patch",
-          "exitCode": 0,
-          "rewrittenFiles": [
-            "requirements.txt"
-          ],
-          "redirected": 1,
-          "warnings": []
-        },
-        {
-          "command": "requirements-plain-hosted-pip-sync",
+          "command": "variant-dependency-groups-hosted-plain-sync",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-plain-variant-2",
-          "exitCode": 0
+          "command": "variant-dependency-groups-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
         },
         {
-          "command": "requirements-plain-vendored-socket-patch",
+          "command": "variant-dependency-groups-vendored-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "vendorSummary": {
             "applied": 1,
             "failed": 0
@@ -3727,63 +21565,72 @@
           "vendorErrors": []
         },
         {
-          "command": "requirements-plain-vendored-pip-sync",
+          "command": "variant-dependency-groups-vendored-frozen-sync",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-hosted-export-sync",
+          "command": "variant-dependency-groups-vendored-locked-sync",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "pylock-hosted-export-sync",
+          "command": "variant-dependency-groups-vendored-plain-sync",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "requirements-vendored-export-sync",
+          "command": "variant-extras-duplicate-hosted-lock",
           "exitCode": 0,
-          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
-          "installedPatch": true
+          "formatSupported": true
         },
         {
-          "command": "pylock-vendored-export-sync",
+          "command": "variant-extras-duplicate-hosted-socket-patch",
           "exitCode": 0,
-          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
-          "installedPatch": true
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
         },
         {
-          "command": "script-lock-hosted",
-          "exitCode": 0
+          "command": "variant-extras-duplicate-hosted-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "script-direct-hosted-socket-patch",
+          "command": "variant-extras-duplicate-hosted-locked-sync-variant-2",
           "exitCode": 0,
-          "rewrittenFiles": [
-            "example.py",
-            "example.py.lock"
-          ],
-          "redirected": 1,
-          "warnings": []
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
         },
         {
-          "command": "script-direct-hosted-install",
+          "command": "variant-extras-duplicate-hosted-plain-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-lock-vendored",
-          "exitCode": 0
+          "command": "variant-extras-duplicate-vendored-lock",
+          "exitCode": 0,
+          "formatSupported": true
         },
         {
-          "command": "script-direct-vendored-socket-patch",
+          "command": "variant-extras-duplicate-vendored-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "vendorSummary": {
             "applied": 1,
             "failed": 0
@@ -3791,41 +21638,72 @@
           "vendorErrors": []
         },
         {
-          "command": "script-direct-vendored-install",
+          "command": "variant-extras-duplicate-vendored-frozen-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-pylock-hosted",
+          "command": "variant-extras-duplicate-vendored-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-extras-duplicate-vendored-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-lock",
           "exitCode": 0,
           "formatSupported": true
         },
         {
-          "command": "pylock-direct-hosted-socket-patch",
+          "command": "variant-constraints-hosted-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "rewrittenFiles": [
-            "pylock.toml"
+            "pyproject.toml",
+            "uv.lock"
           ],
           "redirected": 1,
           "warnings": []
         },
         {
-          "command": "pylock-direct-hosted-install",
+          "command": "variant-constraints-hosted-frozen-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "compile-pylock-vendored",
+          "command": "variant-constraints-hosted-locked-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-hosted-plain-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
+          "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
+          "installedPatch": true
+        },
+        {
+          "command": "variant-constraints-vendored-lock",
           "exitCode": 0,
           "formatSupported": true
         },
         {
-          "command": "pylock-direct-vendored-socket-patch",
+          "command": "variant-constraints-vendored-socket-patch",
           "exitCode": 0,
+          "patchInLock": true,
           "vendorSummary": {
             "applied": 1,
             "failed": 0
@@ -3833,61 +21711,96 @@
           "vendorErrors": []
         },
         {
-          "command": "pylock-direct-vendored-install",
+          "command": "variant-constraints-vendored-frozen-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-hosted-locked-install-variant-2",
+          "command": "variant-constraints-vendored-locked-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-hosted-unfrozen-install-variant-2",
+          "command": "variant-constraints-vendored-plain-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-locked-install-variant-2",
+          "command": "variant-transitive-hosted-lock",
+          "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-hosted-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "rewrittenFiles": [
+            "pyproject.toml",
+            "uv.lock"
+          ],
+          "redirected": 1,
+          "warnings": []
+        },
+        {
+          "command": "variant-transitive-hosted-frozen-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "project-vendored-unfrozen-install-variant-2",
+          "command": "variant-transitive-hosted-locked-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-hosted-locked-install",
+          "command": "variant-transitive-hosted-plain-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-hosted-unfrozen-install",
+          "command": "variant-transitive-vendored-lock",
           "exitCode": 0,
+          "formatSupported": true
+        },
+        {
+          "command": "variant-transitive-vendored-socket-patch",
+          "exitCode": 0,
+          "patchInLock": true,
+          "vendorSummary": {
+            "applied": 1,
+            "failed": 0
+          },
+          "vendorErrors": []
+        },
+        {
+          "command": "variant-transitive-vendored-frozen-sync-variant-2",
+          "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-vendored-locked-install",
+          "command": "variant-transitive-vendored-locked-sync-variant-2",
           "exitCode": 0,
           "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         },
         {
-          "command": "script-vendored-unfrozen-install",
+          "command": "variant-transitive-vendored-plain-sync-variant-2",
           "exitCode": 0,
+          "lockUnchanged": true,
           "installedResponseSha256": "21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4",
           "installedPatch": true
         }
diff --git a/scripts/backtest-uv.py b/scripts/backtest-uv.py
index 18173127..4f07d734 100644
--- a/scripts/backtest-uv.py
+++ b/scripts/backtest-uv.py
@@ -7,6 +7,7 @@
 import re
 import shutil
 import subprocess
+import textwrap
 import zipfile
 
 import argparse
@@ -15,33 +16,97 @@
 import sys
 import urllib.request
 
+# Every 0.x release family, first and latest release of each, plus the
+# releases on either side of each behaviour boundary observed with real
+# binaries (the lower one is the last release WITHOUT the feature):
+#   0.1.23 / 0.1.24  `uv pip sync` accepts bare `./wheel` requirement paths
+#   0.1.44 / 0.1.45  `uv lock` writes a lock (the subcommand exists from 0.1.42
+#                    but panics "not yet implemented" through 0.1.44)
+#   0.2.5  / 0.2.6   `[[distribution]]` artifacts: `[distribution.sdist]` /
+#                    `[[distribution.wheel]]` tables -> inline `sdist = {…}` /
+#                    `wheels = [...]` values
+#   0.2.17 / 0.2.18  `[[distribution]]` sources: `"registry+…"` strings ->
+#                    inline tables (`{ registry = … }`)
+#   0.2.34 / 0.2.35  uv.lock `[[distribution]]` -> `[[package]]` grammar
+#   0.2.36 / 0.2.37  root `[package.metadata]` (requires-dist) appears
+#   0.4.0  / 0.4.1   `uv export`
+#   0.5.16 / 0.5.17  `uv lock --script`
+#   0.6.14 / 0.6.15  PEP 751 `pip compile -o pylock.toml`; lock revision 1 -> 2
+#   0.8.3  / 0.8.4   lock revision 2 -> 3
 VERSIONS = [
     '0.0.5',
+    '0.1.0',
+    '0.1.23',
+    '0.1.24',
+    '0.1.44',
     '0.1.45',
+    '0.2.0',
+    '0.2.5',
+    '0.2.6',
+    '0.2.17',
+    '0.2.18',
+    '0.2.34',
+    '0.2.35',
+    '0.2.36',
     '0.2.37',
+    '0.3.0',
     '0.3.5',
+    '0.4.0',
+    '0.4.1',
     '0.4.30',
+    '0.5.0',
+    '0.5.16',
+    '0.5.17',
     '0.5.31',
     '0.6.0',
+    '0.6.14',
+    '0.6.15',
     '0.6.17',
+    '0.7.0',
     '0.7.22',
+    '0.8.0',
+    '0.8.3',
+    '0.8.4',
     '0.8.24',
+    '0.9.0',
     '0.9.30',
+    '0.10.0',
     '0.10.12',
+    '0.11.0',
     '0.11.33',
-    '0.12.13',
+    '0.12.0',
+    '0.12.15',
 ]
 parser = argparse.ArgumentParser()
-parser.add_argument('--socket-patch', type=Path, required=True)
-parser.add_argument('--socket-patch-revision', required=True)
-parser.add_argument('--output', type=Path, required=True)
+parser.add_argument('--socket-patch', type=Path)
+parser.add_argument('--socket-patch-revision')
+parser.add_argument('--output', type=Path)
 parser.add_argument('--python', default=sys.executable)
 parser.add_argument('--versions', nargs='+', default=VERSIONS)
+parser.add_argument(
+    '--render-doc-table',
+    type=Path,
+    metavar='RESULTS_JSON',
+    help='print the generated section of docs/testing/uv-compatibility.md '
+    'from an existing results.json instead of running the matrix',
+)
 args = parser.parse_args()
-ROOT = args.output.resolve()
-CLI = args.socket_patch.resolve()
-BOOTSTRAP = ROOT / 'bin/0.12.13/uv'
-WHEEL = ROOT / 'urllib3-1.26.18-py2.py3-none-any.whl'
+if args.render_doc_table is None:
+    missing = [
+        flag
+        for flag, value in [
+            ('--socket-patch', args.socket_patch),
+            ('--socket-patch-revision', args.socket_patch_revision),
+            ('--output', args.output),
+        ]
+        if value is None
+    ]
+    if missing:
+        parser.error('the following arguments are required: ' + ', '.join(missing))
+ROOT = args.output.resolve() if args.output else None
+CLI = args.socket_patch.resolve() if args.socket_patch else None
+BOOTSTRAP = ROOT / 'bin/0.12.15/uv' if ROOT else None
+WHEEL = ROOT / 'urllib3-1.26.18-py2.py3-none-any.whl' if ROOT else None
 ENV = {
     key: value
     for key, value in os.environ.items()
@@ -49,7 +114,10 @@
 }
 ENV['SOCKET_NO_CONFIG'] = '1'
 ENV['SOCKET_TELEMETRY_DISABLED'] = '1'
-ROOT.mkdir(parents=True, exist_ok=True)
+if ROOT:
+    ROOT.mkdir(parents=True, exist_ok=True)
+PATCHED_RESPONSE = '21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4'
+PATCH_UUID = 'e828efa5-5c6d-43f3-9909-03f5ac232b98'
 
 
 def fetch_json(url):
@@ -78,7 +146,7 @@ def install_binaries():
         raise ValueError('This backtest requires macOS or Linux')
     registry = fetch_json('https://pypi.org/pypi/uv/json')
     records = []
-    for version in dict.fromkeys([*args.versions, '0.12.13']):
+    for version in dict.fromkeys([*args.versions, '0.12.15']):
         file = next(
             file
             for file in registry['releases'][version]
@@ -214,24 +282,25 @@ def project_matrix(version):
             if scan['exitCode'] != 0:
                 continue
             if kind == 'project':
+                # `uv export` exists from 0.4.1 but `--output-file` only from
+                # 0.4.7, so capture stdout instead of passing the flag: the
+                # export-boundary release 0.4.1 otherwise records exit 2 for a
+                # lane whose stdout export installs fine. Write the file only on
+                # success; an empty file would masquerade as a lock for
+                # format_matrix.
                 for fmt, filename in [
                     ('requirements-txt', 'export-requirements.txt'),
                     ('pylock.toml', 'pylock.toml'),
                 ]:
-                    run(
+                    export = run(
                         exe,
-                        [
-                            'export',
-                            '--frozen',
-                            '--format',
-                            fmt,
-                            '--output-file',
-                            filename,
-                        ],
+                        ['export', '--frozen', '--format', fmt],
                         case,
                         kind + '-' + mode + '-export-' + fmt,
                         rows,
                     )
+                    if export['exitCode'] == 0 and export['stdout']:
+                        (case / filename).write_text(export['stdout'])
                 help_out = subprocess.run(
                     [str(exe), 'sync', '--help'], capture_output=True, text=True
                 )
@@ -362,7 +431,19 @@ def requirements_matrix(version):
             sync['installedResponseSha256'] = hashlib.sha256(
                 target.read_bytes()
             ).hexdigest()
-    if version == '0.2.37':
+    # Older uv binaries (0.2.x, 0.3.0) cannot build the ROOT fixture from an
+    # empty cache under --offline: `setuptools>=40.8.0` is a build dependency
+    # of the fixture itself, not of the patched wheel. Distinguish that from a
+    # failure to install the patched wheel by retrying the frozen install with
+    # network access and recording it as its own row.
+    backtest = json.loads((base / 'backtest.json').read_text())['commands']
+    offline_root_build_failure = any(
+        row['key'] == 'project-vendored-lock-sync'
+        and row['exitCode'] != 0
+        and 'setuptools' in row['stderr']
+        for row in backtest
+    )
+    if offline_root_build_failure:
         case = base / 'project-vendored'
         sync = run(
             exe,
@@ -573,11 +654,7 @@ def unfrozen_matrix(version):
                 else ['example.py', 'example.py.lock']
             )
             lockfile = source / names[1]
-            if (
-                not lockfile.is_file()
-                or 'e828efa5-5c6d-43f3-9909-03f5ac232b98'
-                not in lockfile.read_text()
-            ):
+            if not lockfile.is_file() or PATCH_UUID not in lockfile.read_text():
                 continue
             case = base / (kind + '-unfrozen-' + mode)
             case.mkdir(exist_ok=True)
@@ -647,10 +724,203 @@ def unfrozen_matrix(version):
     }
 
 
-def write_summary():
-    patched_response = (
-        '21d9a7810de52973c88d9170f437e98921456bce445ab0618576987478a6a6e4'
+VARIANT_HEAD = (
+    '[project]\nname = "socket-uv-patch-fixture"\n'
+    'version = "0.1.0"\nrequires-python = ">=3.9"\n'
+)
+# Project shapes the plain `dependencies = ["urllib3==1.26.18"]` fixture never
+# reaches: the `[tool.uv] dev-dependencies` and PEP 735 `[dependency-groups]`
+# requires-dev paths, a duplicate requires-dist entry (extras), a `[manifest]`
+# constraints entry, and the transitive (override-dependencies) branch.
+# Each is locked fresh, scanned in both modes, then installed with `--frozen`,
+# `--locked` (where the binary has it) and a plain `uv sync`, recording the
+# installed bytes and whether the patched lock survived untouched.
+# `requires` is the lock predicate that must hold for the fixture to be
+# meaningful on that binary; failing it records `formatSupported: false`.
+VARIANTS = [
+    (
+        'tool-uv-dev',
+        VARIANT_HEAD
+        + 'dependencies = []\n\n[tool.uv]\ndev-dependencies = ["urllib3==1.26.18"]\n',
+        lambda lock: 'name = "urllib3"' in lock,
+    ),
+    (
+        'dependency-groups',
+        VARIANT_HEAD
+        + 'dependencies = []\n\n[dependency-groups]\ndev = ["urllib3==1.26.18"]\n',
+        # PEP 735 groups are honoured from uv 0.4.27; older binaries lock an
+        # empty project.
+        lambda lock: 'name = "urllib3"' in lock,
+    ),
+    (
+        'extras-duplicate',
+        VARIANT_HEAD
+        + 'dependencies = ["urllib3==1.26.18"]\n\n'
+        '[project.optional-dependencies]\nhttp = ["urllib3==1.26.18"]\n',
+        lambda lock: 'name = "urllib3"' in lock,
+    ),
+    (
+        'constraints',
+        VARIANT_HEAD
+        + 'dependencies = ["urllib3==1.26.18"]\n\n'
+        '[tool.uv]\nconstraint-dependencies = ["urllib3==1.26.18"]\n',
+        # Older uv locks the project without recording the constraint.
+        lambda lock: re.search(r'^constraints = \[', lock, re.MULTILINE) is not None,
+    ),
+    (
+        'transitive',
+        # requests 2.28.2 pins urllib3 <1.27; the cut-off keeps it at 1.26.18.
+        # It lives in pyproject rather than on the `uv lock` command line so
+        # every later `uv sync` sees the same setting: a command-line
+        # `--exclude-newer` is recorded under `[options]` and its absence on
+        # sync makes uv re-resolve ("removal of global exclude newer"), which
+        # would fail `--locked` for a reason unrelated to the patch.
+        VARIANT_HEAD
+        + 'dependencies = ["requests==2.28.2"]\n\n'
+        '[tool.uv]\nexclude-newer = "2024-01-01T00:00:00Z"\n',
+        lambda lock: 'name = "urllib3"\nversion = "1.26.18"' in lock,
+    ),
+]
+VARIANT_INSTALLS = ['frozen', 'locked', 'plain']
+
+
+def variant_matrix(version):
+    exe = ROOT / 'bin' / version / 'uv'
+    base = ROOT / 'matrix' / version
+    original_lock = base / 'original' / 'uv.lock'
+    if (
+        not original_lock.is_file()
+        or '[[package]]' not in original_lock.read_text()
+    ):
+        # `[[distribution]]`-grammar binaries cannot vendor natively and the
+        # hosted path is covered by project_matrix; nothing to add here.
+        return {'version': version, 'commands': []}
+    sync_help = subprocess.run(
+        [str(exe), 'sync', '--help'], capture_output=True, text=True
+    ).stdout
+    rows = []
+    for name, pyproject, requires in VARIANTS:
+        for mode in ['hosted', 'vendored']:
+            prefix = 'variant-' + name + '-' + mode
+            case = base / prefix
+            if case.exists():
+                shutil.rmtree(case)
+            case.mkdir(parents=True)
+            (case / 'pyproject.toml').write_text(pyproject)
+            lock = run(
+                exe, ['lock', '--python', args.python], case, prefix + '-lock', rows
+            )
+            lock_text = (
+                (case / 'uv.lock').read_text() if (case / 'uv.lock').is_file() else ''
+            )
+            lock['formatSupported'] = lock['exitCode'] == 0 and bool(requires(lock_text))
+            if not lock['formatSupported']:
+                continue
+            bootstrap(case, rows)
+            scan = run(
+                CLI,
+                [
+                    'scan',
+                    '--cwd',
+                    str(case),
+                    '--mode',
+                    mode,
+                    '--json',
+                    '--yes',
+                    '--no-telemetry',
+                ],
+                case,
+                prefix + '-socket-patch',
+                rows,
+            )
+            scan['patchInLock'] = PATCH_UUID in (case / 'uv.lock').read_text()
+            if scan['exitCode'] != 0 or not scan['patchInLock']:
+                continue
+            sync_args = ['sync', '--python', args.python]
+            if '--no-install-project' in sync_help:
+                sync_args.append('--no-install-project')
+            else:
+                package = case / 'socket_uv_patch_fixture'
+                package.mkdir(exist_ok=True)
+                (package / '__init__.py').write_text('')
+            locked = (case / 'uv.lock').read_bytes()
+            for label in VARIANT_INSTALLS:
+                flag = {'frozen': '--frozen', 'locked': '--locked', 'plain': None}[label]
+                if flag and flag not in sync_help:
+                    continue
+                shutil.rmtree(case / '.venv', ignore_errors=True)
+                if label == 'frozen':
+                    shutil.rmtree(case / '.uv-cache', ignore_errors=True)
+                command = [sync_args[0], *([flag] if flag else []), *sync_args[1:]]
+                sync = run(exe, command, case, prefix + '-' + label + '-sync', rows)
+                # Recorded, never raised: a plain `uv sync` that re-resolves
+                # the lock (uv < 0.5.6 on the transitive fixture) is a real
+                # observation the doc explains, not a harness error.
+                sync['lockUnchanged'] = (case / 'uv.lock').read_bytes() == locked
+                if sync['exitCode'] == 0:
+                    targets = list(
+                        (case / '.venv/lib').glob(
+                            'python*/site-packages/urllib3/response.py'
+                        )
+                    )
+                    sync['installedResponseSha256'] = (
+                        hashlib.sha256(targets[0].read_bytes()).hexdigest()
+                        if targets
+                        else None
+                    )
+    (base / 'variant-backtest.json').write_text(
+        json.dumps({'version': version, 'commands': rows}, indent=2) + '\n'
     )
+    return {
+        'version': version,
+        'commands': [
+            (row['key'], row['exitCode'])
+            for row in rows
+            if row['key'] not in ['venv', 'install-original']
+        ],
+    }
+
+
+def variant_status(observations, name, mode):
+    """Collapse one fixture/mode's observations into the doc-table verdict.
+
+    Returns None when the lane did not run (uv < 0.2.35), 'unsupported' when
+    the binary cannot lock the fixture shape, 'refused' when the CLI left the
+    lock unpatched, 'pass' when every executed install delivered the patched
+    bytes and the `--locked` install left the lock untouched, otherwise
+    ('fail', [failing install labels]).
+    """
+    prefix = 'variant-' + name + '-' + mode + '-'
+    rows = {
+        re.sub(r'-variant-\d+$', '', item['command'])[len(prefix):]: item
+        for item in observations
+        if item['command'].startswith(prefix)
+    }
+    if not rows:
+        return None
+    lock = rows.get('lock')
+    if lock is None or lock.get('formatSupported') is False or lock['exitCode']:
+        return 'unsupported'
+    scan = rows.get('socket-patch')
+    if scan is None or scan['exitCode']:
+        return ('fail', ['scan'])
+    if scan.get('patchInLock') is False:
+        return 'refused'
+    failed = []
+    for label in VARIANT_INSTALLS:
+        item = rows.get(label + '-sync')
+        if item is None:
+            continue
+        ok = item['exitCode'] == 0 and item.get('installedPatch') is True
+        if label == 'locked' and item.get('lockUnchanged') is not True:
+            ok = False
+        if not ok:
+            failed.append(label)
+    return 'pass' if not failed else ('fail', failed)
+
+
+def write_summary():
+    patched_response = PATCHED_RESPONSE
     versions = []
     command_catalog = {}
     for version in args.versions:
@@ -665,6 +935,7 @@ def write_summary():
             'backtest-extensions.json',
             'format-backtest.json',
             'unfrozen-backtest.json',
+            'variant-backtest.json',
         ]:
             path = base / filename
             if not path.exists():
@@ -708,6 +979,8 @@ def write_summary():
                     item['formatSupported'] = row['formatSupported']
                 if 'lockUnchanged' in row:
                     item['lockUnchanged'] = row['lockUnchanged']
+                if 'patchInLock' in row:
+                    item['patchInLock'] = row['patchInLock']
                 if row.get('installedResponseSha256'):
                     item['installedResponseSha256'] = row['installedResponseSha256']
                     item['installedPatch'] = (
@@ -748,18 +1021,30 @@ def write_summary():
                 else None,
                 'lockVersion': 1 if lock else None,
                 'lockRevision': int(revision.group(1)) if revision else None,
+                'variants': {
+                    name: {
+                        mode: variant_status(observations, name, mode)
+                        for mode in ['hosted', 'vendored']
+                    }
+                    for name, _, _ in VARIANTS
+                },
                 'observations': observations,
             }
         )
     result = {
         'date': datetime.date.today().isoformat(),
         'scope': f'{len(args.versions)} pinned uv releases on {platform.platform()}; interpreter {args.python}',
+        'pythonVersion': subprocess.check_output(
+            [args.python, '--version'], text=True, stderr=subprocess.STDOUT
+        )
+        .strip()
+        .split()[-1],
         'socketPatchRevision': args.socket_patch_revision,
         'socketPatchVersion': subprocess.check_output(
             [str(CLI), '--version'], text=True
         ).strip(),
         'socketPatchBinarySha256': hashlib.sha256(CLI.read_bytes()).hexdigest(),
-        'patchUuid': 'e828efa5-5c6d-43f3-9909-03f5ac232b98',
+        'patchUuid': PATCH_UUID,
         'originalWheelSha256': hashlib.sha256(WHEEL.read_bytes()).hexdigest(),
         'patchedWheelSha256': 'ccc9a9e0b18a5efc7038c504cfc580e47d2e02e5390f2e29cad833cbccb956b6',
         'patchedResponseSha256': patched_response,
@@ -775,16 +1060,273 @@ def write_summary():
     (ROOT / 'results.json').write_text(text)
 
 
+def render_doc_table(results):
+    """Render the generated section of docs/testing/uv-compatibility.md.
+
+    Everything between the GENERATED markers in that document comes from
+    here, so the merger can paste a fresh run's tables without hand-editing:
+    the run header, the per-release results table and the project-variant
+    table. The prose that explains the nonzero outcomes stays hand-written
+    outside the markers.
+    """
+    hosted_vendored = ['hosted', 'vendored']
+
+    def installs(obs):
+        return [
+            item
+            for item in obs
+            if item['exitCode'] == 0 and item.get('installedResponseSha256')
+        ]
+
+    def verdict(obs, unavailable_when_empty=True):
+        # Pass: every completed install delivered the patched bytes and every
+        # recorded lock check held; a failed install is a Fail unless it is
+        # the cold-offline root build the harness retried with network (the
+        # retry row is one of `obs` and counts like any other install).
+        if not obs:
+            return '—' if unavailable_when_empty else 'Fail'
+        done = installs(obs)
+        failed = [
+            item
+            for item in obs
+            if item['exitCode'] != 0 and 'root-build-networked' not in item['command']
+        ]
+        retried = any('root-build-networked' in item['command'] for item in obs)
+        if failed and not (retried and all('lock-sync' in item['command'] for item in failed)):
+            return 'Fail'
+        if not done:
+            return '—' if unavailable_when_empty else 'Fail'
+        if all(item.get('installedPatch') for item in done) and all(
+            item.get('lockUnchanged', True) for item in obs
+        ):
+            return 'Pass¹' if retried else 'Pass'
+        return 'Fail'
+
+    def rows_matching(obs, patterns):
+        return [
+            item
+            for item in obs
+            if any(
+                re.fullmatch(pattern + r'(-variant-\d+)?', item['command'])
+                for pattern in patterns
+            )
+        ]
+
+    def refusal(obs, pattern):
+        scans = rows_matching(obs, [pattern])
+        if not scans:
+            return None
+        scan = scans[0]
+        if scan['exitCode'] == 0 and not scan.get('vendorErrors'):
+            return False
+        if scan.get('vendorErrors') or scan.get('warnings'):
+            return 'refused'
+        return 'Fail'
+
+    def paragraph(text):
+        lines.extend(textwrap.wrap(text, width=80, break_long_words=False, break_on_hyphens=False))
+        lines.append('')
+
+    lines = []
+    platform_name = results['scope'].split(' on ', 1)[1].split(';')[0]
+    python_version = results.get('pythonVersion') or results['scope'].split(
+        'interpreter ', 1
+    )[-1]
+    paragraph(
+        f"The complete run finished on **{results['date']}**, using "
+        f"**{platform_name}** and Python **{python_version}**. It tested "
+        f"socket-patch source commit `{results['socketPatchRevision']}` "
+        f"(`{results['socketPatchVersion']}`), with binary SHA-256:"
+    )
+    lines.extend(['```text', results['socketPatchBinarySha256'], '```', ''])
+    all_obs = [item for version in results['versions'] for item in version['observations']]
+    compared = [item for item in all_obs if 'installedPatch' in item]
+    mismatches = [item for item in compared if not item['installedPatch']]
+    lock_checks = [item for item in all_obs if 'lockUnchanged' in item]
+    lock_changed = [item for item in lock_checks if not item['lockUnchanged']]
+    locked_rows = [item for item in lock_checks if 'locked' in item['command']]
+    locked_ok = sum(1 for item in locked_rows if item['exitCode'] == 0)
+    paragraph(
+        f"**{len(compared)} installed-byte comparisons** ran, with "
+        f"**{len(mismatches)} mismatch{'es' if len(mismatches) != 1 else ''}**. "
+        f"**{len(lock_checks)} lock-preservation checks** were recorded — every "
+        "install attempt against a patched lock (`--frozen` and `--locked` where "
+        "the binary provides them, plain `uv sync` where it does not, "
+        "`uv run --frozen --script`, `uv pip sync pylock.toml`, and the "
+        "project-variant installs), including failed installs whose lock was left "
+        f"untouched — and **{len(lock_changed)} changed the lock**. `--frozen` "
+        f"never writes the lock, so the {len(locked_rows)} `--locked` rows are the "
+        f"ones that measure preservation; {locked_ok} of them exited 0. The "
+        "[machine-readable results](uv-compatibility/results.json) contain all "
+        f"{len(all_obs)} observations and their command definitions. The "
+        "[binary catalog](uv-compatibility/binaries.json) records each uv wheel's "
+        "public PyPI source and verified hash."
+    )
+    paragraph(
+        'Each paired result below is **hosted / vendored**. “Pass” means the '
+        'installed `urllib3/response.py` matched the published patch; “—” means '
+        'that uv binary did not provide the format or command. Requirements '
+        'include plain and hashed compilation. PEP 751 covers both standalone '
+        'locks and exported locks.'
+    )
+    lines.append(
+        '| uv | Native grammar | Native H/V | Requirements H/V | Requirements export H/V | Scripts H/V | PEP 751 H/V | Verified installs |'
+    )
+    lines.append(
+        '|----|----------------|------------|------------------|-------------------------|-------------|-------------|-------------------|'
+    )
+    for version in results['versions']:
+        obs = version['observations']
+        schema = version.get('lockSchema')
+        if not schema:
+            grammar = 'No native lock'
+        else:
+            grammar = f"`{schema}`, v{version.get('lockVersion') or 1}"
+            if version.get('lockRevision'):
+                grammar += f" r{version['lockRevision']}"
+        cells = []
+        native = []
+        for mode in hosted_vendored:
+            refused = refusal(obs, f'project-{mode}-socket-patch')
+            if refused is None:
+                native.append('—')
+            elif refused:
+                native.append(refused)
+            else:
+                native.append(
+                    verdict(
+                        rows_matching(
+                            obs,
+                            [
+                                f'project-{mode}-lock-sync',
+                                f'project-{mode}-locked-install',
+                                f'project-{mode}-unfrozen-install',
+                                f'project-{mode}-frozen-sync-root-build-networked',
+                            ],
+                        ),
+                        unavailable_when_empty=False,
+                    )
+                )
+        cells.append(' / '.join(native))
+        requirements = []
+        for mode in hosted_vendored:
+            syncs = rows_matching(
+                obs, [f'requirements-{mode}-pip-sync', f'requirements-plain-{mode}-pip-sync']
+            )
+            if any(
+                "Unexpected '.'" in item.get('diagnostic', '')
+                for item in syncs
+                if item['exitCode']
+            ):
+                requirements.append('rejected path')
+            else:
+                requirements.append(verdict(syncs))
+        cells.append(' / '.join(requirements))
+        cells.append(
+            ' / '.join(
+                verdict(rows_matching(obs, [f'requirements-{mode}-export-sync']))
+                for mode in hosted_vendored
+            )
+        )
+        cells.append(
+            ' / '.join(
+                verdict(
+                    rows_matching(
+                        obs,
+                        [
+                            f'script-direct-{mode}-install',
+                            f'script-{mode}-locked-install',
+                            f'script-{mode}-unfrozen-install',
+                        ],
+                    )
+                )
+                for mode in hosted_vendored
+            )
+        )
+        cells.append(
+            ' / '.join(
+                verdict(
+                    rows_matching(
+                        obs,
+                        [f'pylock-{mode}-export-sync', f'pylock-direct-{mode}-install'],
+                    )
+                )
+                for mode in hosted_vendored
+            )
+        )
+        verified = sum(1 for item in obs if item.get('installedPatch'))
+        lines.append(
+            f"| {version['version']} | {grammar} | {' | '.join(cells)} | {verified} |"
+        )
+    lines.append('')
+    lines.extend(['### Project variants (uv ≥ 0.2.35)', ''])
+    paragraph(
+        'Each `[[package]]`-grammar binary also locks five further project shapes '
+        '(`variant-*` cases in the results), scans them in both modes, and '
+        'installs from the patched lock with `--frozen`, `--locked` (where '
+        'available) and a plain `uv sync`, each into a fresh environment. “Pass” '
+        'requires the patched bytes from every executed install and an untouched '
+        'lock after `--locked`; “Fail: …” names the installs that missed; '
+        '“refused” means the CLI reported the shape unsupported and left the lock '
+        'unpatched; “—” means the binary cannot lock that shape (no '
+        '`[dependency-groups]`, no `[manifest]` constraints, or no '
+        '`exclude-newer` setting).'
+    )
+    names = [name for name, _, _ in VARIANTS]
+    variant_rows = []
+    for version in results['versions']:
+        statuses = version.get('variants') or {
+            name: {
+                mode: variant_status(version['observations'], name, mode)
+                for mode in hosted_vendored
+            }
+            for name in names
+        }
+        if all(statuses[name][mode] is None for name in names for mode in hosted_vendored):
+            continue
+        cells = []
+        for name in names:
+            pair = []
+            for mode in hosted_vendored:
+                status = statuses[name][mode]
+                if status is None or status == 'unsupported':
+                    pair.append('—')
+                elif status == 'pass':
+                    pair.append('Pass')
+                elif status == 'refused':
+                    pair.append('refused')
+                else:
+                    pair.append('Fail: ' + ', '.join(status[1]))
+            cells.append(' / '.join(pair))
+        variant_rows.append(f"| {version['version']} | {' | '.join(cells)} |")
+    if variant_rows:
+        lines.append('| uv | ' + ' | '.join(name + ' H/V' for name in names) + ' |')
+        lines.append('|----|' + '|'.join('-' * (len(name) + 6) for name in names) + '|')
+        lines.extend(variant_rows)
+    else:
+        lines.append(
+            '_This results.json predates the project-variant lane; rerun the '
+            'matrix to populate this table._'
+        )
+    return '\n'.join(lines) + '\n'
+
+
 def backtest(version):
     return [
         project_matrix(version),
         requirements_matrix(version),
         format_matrix(version),
         unfrozen_matrix(version),
+        variant_matrix(version),
     ]
 
 
 if __name__ == '__main__':
+    if args.render_doc_table is not None:
+        sys.stdout.write(
+            render_doc_table(json.loads(args.render_doc_table.read_text()))
+        )
+        sys.exit(0)
     install_binaries()
     provenance = {
         'socketPatchRevision': args.socket_patch_revision,
diff --git a/scripts/probe-uv-boundaries.py b/scripts/probe-uv-boundaries.py
new file mode 100644
index 00000000..56f0310f
--- /dev/null
+++ b/scripts/probe-uv-boundaries.py
@@ -0,0 +1,211 @@
+"""Probe uv behaviour boundaries with real binaries.
+
+For every requested uv release this downloads the PyPI wheel for the current
+platform (hash-verified), extracts the `uv` binary, and records:
+
+- whether the `uv lock` subcommand exists (`lockCommand`; it appears in
+  0.1.42 but panics "not yet implemented" through 0.1.44) and whether it
+  actually writes a lock (`lock`; first true at 0.1.45), which native lock
+  grammar it writes (`[[distribution]]` vs `[[package]]`), whether sources
+  are strings or inline tables, whether artifacts are sub-tables or inline
+  values, plus the lock `revision`;
+- whether `uv export` (0.4.1), its `--output-file` flag (0.4.7; the backtest
+  reads stdout below that) and `uv lock --script` (0.5.17) exist;
+- whether `uv pip compile --output-file pylock.toml` writes PEP 751;
+- whether `uv pip sync` accepts a bare `./wheel --hash=…` requirement line
+  (the shape vendored requirements use).
+
+It is the bisection tool behind the boundary versions pinned in
+`scripts/backtest-uv.py`; see docs/testing/uv-compatibility.md. One JSON object
+per version is printed to stdout.
+
+    python3 scripts/probe-uv-boundaries.py --output /tmp/uv-probe \
+        --python /path/to/python3.9 0.2.34 0.2.35 0.8.3 0.8.4
+"""
+import argparse
+import hashlib
+import io
+import json
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import tempfile
+import urllib.request
+import zipfile
+from pathlib import Path
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--output', type=Path, required=True)
+parser.add_argument('--python', default=sys.executable)
+parser.add_argument('versions', nargs='+')
+args = parser.parse_args()
+ROOT = args.output.resolve()
+ROOT.mkdir(parents=True, exist_ok=True)
+WHEEL_NAME = 'urllib3-1.26.18-py2.py3-none-any.whl'
+ENV = {
+    key: value
+    for key, value in os.environ.items()
+    if not key.startswith(('UV_', 'PIP_', 'PYTHON')) and key != 'VIRTUAL_ENV'
+}
+
+
+def fetch_json(url):
+    with urllib.request.urlopen(url, timeout=90) as response:
+        return json.load(response)
+
+
+def download(file):
+    with urllib.request.urlopen(file['url'], timeout=180) as response:
+        data = response.read()
+    if hashlib.sha256(data).hexdigest() != file['digests']['sha256']:
+        raise ValueError('download hash mismatch: ' + file['filename'])
+    return data
+
+
+def platform_markers():
+    system = platform.system()
+    machine = platform.machine().lower()
+    if system == 'Darwin':
+        return 'macosx', 'arm64' if machine in ['arm64', 'aarch64'] else 'x86_64'
+    if system == 'Linux':
+        return 'manylinux', 'aarch64' if machine in ['arm64', 'aarch64'] else 'x86_64'
+    raise ValueError('This probe requires macOS or Linux')
+
+
+REGISTRY = fetch_json('https://pypi.org/pypi/uv/json')
+
+
+def binary(version):
+    folder = ROOT / 'bin' / version
+    exe = folder / 'uv'
+    if exe.exists():
+        return exe
+    marker, architecture = platform_markers()
+    file = next(
+        file
+        for file in REGISTRY['releases'][version]
+        if marker in file['filename'] and architecture in file['filename']
+    )
+    folder.mkdir(parents=True, exist_ok=True)
+    archive = zipfile.ZipFile(io.BytesIO(download(file)))
+    member = next(name for name in archive.namelist() if name.endswith('/uv'))
+    exe.write_bytes(archive.read(member))
+    exe.chmod(0o755)
+    return exe
+
+
+def wheel():
+    path = ROOT / WHEEL_NAME
+    if not path.exists():
+        release = fetch_json('https://pypi.org/pypi/urllib3/1.26.18/json')
+        file = next(file for file in release['urls'] if file['filename'] == WHEEL_NAME)
+        path.write_bytes(download(file))
+    return path
+
+
+def run(exe, arguments, cwd):
+    process = subprocess.run(
+        [str(exe), *arguments],
+        cwd=cwd,
+        env=dict(ENV, UV_CACHE_DIR=str(cwd / '.cache')),
+        capture_output=True,
+        text=True,
+        timeout=300,
+    )
+    return process.returncode, process.stdout, process.stderr
+
+
+def diagnostic_line(stderr):
+    """The line that names the failure: a panic location or `error:` line if
+    present (a panic's LAST line is only the RUST_BACKTRACE hint), else the
+    last non-empty line."""
+    lines = [line for line in stderr.strip().splitlines() if line.strip()]
+    if not lines:
+        return ''
+    for line in lines:
+        if 'panicked at' in line or line.startswith('error'):
+            return line[:160]
+    return lines[-1][:160]
+
+
+def probe(version):
+    exe = binary(version)
+    with tempfile.TemporaryDirectory() as raw:
+        cwd = Path(raw)
+        (cwd / 'pyproject.toml').write_text(
+            '[project]\nname = "probe"\nversion = "0.1.0"\n'
+            'requires-python = ">=3.9"\ndependencies = ["urllib3==1.26.18"]\n'
+        )
+        lock_rc, _, lock_err = run(exe, ['lock', '--python', args.python], cwd)
+        lock = (cwd / 'uv.lock').read_text() if (cwd / 'uv.lock').exists() else ''
+        # clap reports a missing subcommand as exit 2 "unrecognized subcommand";
+        # 0.1.42–0.1.44 accept `lock` and then panic (exit 101), so the
+        # subcommand's existence and a written lock are separate facts.
+        lock_command = 'unrecognized subcommand' not in lock_err
+        if '[[distribution]]' in lock:
+            schema = 'distribution'
+        elif '[[package]]' in lock:
+            schema = 'package'
+        else:
+            schema = None
+        revision = next(
+            (line.split('=')[1].strip() for line in lock.splitlines() if line.startswith('revision =')),
+            None,
+        )
+        # uv 0.2.x switched `source = "registry+…"` strings (plus
+        # `[[distribution.dependencies]]` / `[[distribution.wheel]]` tables) to
+        # inline tables (`source = { registry = … }`, `wheels = [...]`) while
+        # still writing `[[distribution]]`; the rewriter must follow the
+        # entry's own shape, not the table name.
+        source_lines = [line for line in lock.splitlines() if line.startswith('source = ')]
+        source_style = None
+        if source_lines:
+            source_style = 'table' if source_lines[0].startswith('source = {') else 'string'
+        # …and, separately, whether artifacts are `[distribution.sdist]` /
+        # `[[distribution.wheel]]` tables or inline `sdist = { … }` /
+        # `wheels = [ … ]` values (the two flipped at different releases).
+        artifact_style = None
+        if '[[distribution.wheel]]' in lock or '[distribution.sdist]' in lock:
+            artifact_style = 'tables'
+        elif 'wheels = [' in lock or 'sdist = {' in lock:
+            artifact_style = 'inline'
+        _, help_out, _ = run(exe, ['--help'], cwd)
+        _, lock_help, _ = run(exe, ['lock', '--help'], cwd)
+        _, export_help, _ = run(exe, ['export', '--help'], cwd)
+        (cwd / 'requirements.in').write_text('urllib3==1.26.18\n')
+        run(
+            exe,
+            ['pip', 'compile', 'requirements.in', '--python-version', '3.9', '-o', 'pylock.toml'],
+            cwd,
+        )
+        pylock = (cwd / 'pylock.toml').read_text() if (cwd / 'pylock.toml').exists() else ''
+        source = wheel()
+        shutil.copy(source, cwd / source.name)
+        sha = hashlib.sha256(source.read_bytes()).hexdigest()
+        (cwd / 'requirements.txt').write_text(f'./{source.name} --hash=sha256:{sha}\n')
+        venv_rc, _, _ = run(exe, ['venv', '.venv', '--python', args.python], cwd)
+        sync_rc, _, sync_err = run(exe, ['pip', 'sync', 'requirements.txt'], cwd)
+        local_ok = venv_rc == 0 and sync_rc == 0
+        return {
+            'uv': version,
+            'lockCommand': lock_command,
+            'lock': lock_rc == 0 and bool(lock),
+            'lockError': '' if lock_rc == 0 else diagnostic_line(lock_err),
+            'lockSchema': schema,
+            'lockRevision': int(revision) if revision else None,
+            'lockSourceStyle': source_style,
+            'lockArtifactStyle': artifact_style,
+            'export': 'export' in help_out,
+            'exportOutputFile': '--output-file' in export_help,
+            'lockScript': '--script' in lock_help,
+            'pep751Compile': 'lock-version = ' in pylock,
+            'localWheelRequirements': local_ok,
+            'localWheelError': '' if local_ok else sync_err.strip().splitlines()[-1][:160] if sync_err.strip() else '',
+        }
+
+
+if __name__ == '__main__':
+    for version in args.versions:
+        print(json.dumps(probe(version)), flush=True)