Fix peer ranges dropped from restored yarn lock key

berry_declared_descriptors now reads both dependencies and peerDependencies
when determining which descriptors to keep in a restored lock key. This
fixes YN0028 failures when a peer range differs from the direct dependency
range, since yarn keys entries by the union of all descriptors including
peer requests.

The fix adds dependency_and_peer_descriptors() to read both maps, leaving
dependency_descriptors() unchanged for the prune logic which only tracks
actual dependency edges.

Author: cursoragent

crates/socket-patch-core/src/formats/yarn/berry_prune.rs

@@ -60,6 +60,44 @@ pub(crate) fn dependency_descriptors(stanza: &str) -> Vec<String> {
     out
 }
 
+/// The descriptors (`name@range`) an entry's `dependencies:` and
+/// `peerDependencies:` maps name. Yarn keys a lock entry by the union of
+/// every descriptor that resolved to it, including peer requests.
+pub(crate) fn dependency_and_peer_descriptors(stanza: &str) -> Vec<String> {
+    let mut out = Vec::new();
+    let mut in_deps = false;
+    for line in stanza.lines().skip(1) {
+        if let Some(field) = line.strip_prefix("  ").filter(|r| !r.starts_with(' ')) {
+            in_deps =
+                field.trim_end() == "dependencies:" || field.trim_end() == "peerDependencies:";
+            continue;
+        }
+        if !in_deps {
+            continue;
+        }
+        let Some(rest) = line.strip_prefix("    ").filter(|r| !r.starts_with(' ')) else {
+            continue;
+        };
+        let (name, range) = match rest.strip_prefix('"') {
+            Some(quoted) => match quoted.split_once("\": ") {
+                Some((name, range)) => (name, range),
+                None => continue,
+            },
+            None => match rest.split_once(": ") {
+                Some((name, range)) => (name, range),
+                None => continue,
+            },
+        };
+        let range = range.trim_end();
+        let range = range
+            .strip_prefix('"')
+            .and_then(|r| r.strip_suffix('"'))
+            .unwrap_or(range);
+        out.push(format!("{name}@{range}"));
+    }
+    out
+}
+
 /// The descriptors `before` depends on that `after` (the same entry,
 /// rewritten) no longer does: the edges a rewrite cut.
 pub(crate) fn cut_descriptors(before: &str, after: &str) -> Vec<String> {

crates/socket-patch-core/src/patch/redirect/upstream/npm.rs

@@ -1068,13 +1068,13 @@ async fn restore_berry(
 }
 
 /// The descriptors a berry lock's `stanzas` still declare: every
-/// entry's `dependencies:` map, plus the descriptor a `patch:` descriptor
-/// wraps (`name@patch:name@npm%3A1.3.0#…` wraps `name@npm:1.3.0`), in
-/// either a dependency map or a key. Yarn 4 spells a registry range
-/// `npm:range`, yarn 2 and 3 a bare `range`; see
+/// entry's `dependencies:` and `peerDependencies:` map, plus the
+/// descriptor a `patch:` descriptor wraps (`name@patch:name@npm%3A1.3.0#…`
+/// wraps `name@npm:1.3.0`), in either a dependency map or a key. Yarn 4
+/// spells a registry range `npm:range`, yarn 2 and 3 a bare `range`; see
 /// [`berry_descriptor_declared`].
 fn berry_declared_descriptors(stanzas: &[String]) -> BTreeSet<String> {
-    use crate::formats::yarn::berry_prune::dependency_descriptors;
+    use crate::formats::yarn::berry_prune::dependency_and_peer_descriptors;
     use crate::formats::yarn::patterns::split_berry_key_patterns;
     use crate::formats::yarn::stanzas::stanza_key;
 
@@ -1083,7 +1083,7 @@ fn berry_declared_descriptors(stanzas: &[String]) -> BTreeSet<String> {
         let keys = stanza_key(stanza)
             .map(split_berry_key_patterns)
             .unwrap_or_default();
-        for descriptor in dependency_descriptors(stanza) {
+        for descriptor in dependency_and_peer_descriptors(stanza) {
             if let Some(inner) = berry_patch_inner(&descriptor) {
                 out.insert(inner);
             }