@@ -90,12 +90,13 @@ pub(crate) fn stanza_lines(stanza: &str) -> Vec<String> {
 /// keyed by every descriptor, sorted, and `--immutable` rejects a lock
 /// that keeps them apart (YN0028). The entry yarn wrote keeps its body;
 /// the restored one only adds its keys. The merged key goes to `moved`,
-/// for [`BerryStanzas::render`] to sort.
+/// for [`BerryStanzas::render`] to sort. Returns the indices (before the
+/// call) of the restored stanzas merged away.
 pub(crate) fn merge_same_resolution(
     stanzas: &mut Vec<String>,
     restored: &[usize],
     moved: &mut Vec<String>,
-) -> bool {
+) -> Vec<usize> {
     use super::blocks::berry_field;
     use super::patterns::split_berry_key_patterns;
 
@@ -120,20 +121,23 @@ pub(crate) fn merge_same_resolution(
             .collect();
         patterns.sort();
         patterns.dedup();
-        let old_key = stanza_key(&stanzas[idx]).unwrap_or("").to_string();
-        moved.retain(|k| *k != old_key);
+        for old in [idx, sibling] {
+            let old_key = stanza_key(&stanzas[old]).unwrap_or("").to_string();
+            moved.retain(|k| *k != old_key);
+        }
         let key = format!("\"{}\"", patterns.join(", "));
         let mut lines = stanza_lines(&stanzas[sibling]);
         lines[0] = format!("{key}:");
         stanzas[sibling] = lines.join("\n");
         moved.push(key);
         dropped.push(idx);
     }
-    dropped.sort_unstable_by(|a, b| b.cmp(a));
-    for idx in &dropped {
-        stanzas.remove(*idx);
+    let mut descending = dropped.clone();
+    descending.sort_unstable_by(|a, b| b.cmp(a));
+    for idx in descending {
+        stanzas.remove(idx);
     }
-    !dropped.is_empty()
+    dropped
 }
 
 /// A stanza's sort key: its unquoted key, or `None` for header comment
@@ -199,6 +203,28 @@ mod tests {
         }
     }
 
+    /// #1082: a restored entry joins the entry yarn wrote for the same
+    /// resolution (sorted union of keys, yarn's body); one with no such
+    /// sibling, and an entry of another resolution, are left alone.
+    #[test]
+    fn restored_entries_merge_into_a_sibling_with_their_resolution() {
+        let raw = "__metadata:\n  version: 8\n\n\
+                   \"a@npm:^1.0.0\":\n  version: 1.0.0\n  resolution: \"a@npm:1.0.0\"\n  restored: x\n\n\
+                   \"b@npm:^2\":\n  version: 2.0.0\n  resolution: \"b@npm:2.0.0\"\n\n\
+                   \"c@npm:a@1.0.0\":\n  version: 1.0.0\n  resolution: \"a@npm:1.0.0\"\n  yarn: y\n";
+        let mut doc = BerryStanzas::parse(raw);
+        let mut moved = vec!["\"a@npm:^1.0.0\"".to_string()];
+        let merged = merge_same_resolution(&mut doc.stanzas, &[1, 2], &mut moved);
+        assert_eq!(merged, vec![1]);
+        assert_eq!(moved, vec!["\"a@npm:^1.0.0, c@npm:a@1.0.0\"".to_string()]);
+        assert_eq!(
+            doc.render(&moved),
+            "__metadata:\n  version: 8\n\n\
+             \"a@npm:^1.0.0, c@npm:a@1.0.0\":\n  version: 1.0.0\n  resolution: \"a@npm:1.0.0\"\n  yarn: y\n\n\
+             \"b@npm:^2\":\n  version: 2.0.0\n  resolution: \"b@npm:2.0.0\"\n"
+        );
+    }
+
     #[test]
     fn a_moved_entry_goes_to_its_sorted_place_only_in_a_sorted_lock() {
         let raw = "__metadata:\n  version: 8\n\n\"a@npm:^1\":\n  v: 1\n\n\"b@npm:^1\":\n  v: 1\n";
 
@@ -4806,7 +4806,9 @@ fn rewrite_yarn_berry_with_manifests(
                     .iter()
                     .flat_map(|(_, ranges)| ranges.iter().map(String::as_str))
                     .collect();
-                pin.add_ranges(yarnrc, &fname, &folded_ranges);
+                if !folded_ranges.is_empty() {
+                    pin.add_ranges(yarnrc, &fname, &folded_ranges);
+                }
                 pin
             }
             Err(warning) => {
 
@@ -887,6 +887,9 @@ async fn restore_berry(
     let mut changed = false;
     let mut moved: Vec<String> = Vec::new();
     let mut restored: Vec<usize> = Vec::new();
+    // `(block index, warning)`: kept only for an entry that is not merged
+    // into a sibling below, whose own body yarn wrote.
+    let mut node_gyp_unresolved: Vec<(usize, String)> = Vec::new();
     for Hit {
         idx,
         uuid,
@@ -978,8 +981,8 @@ async fn restore_berry(
             if resolvable {
                 lines = crate::formats::yarn::berry_entry::with_implicit_node_gyp(&lines);
             } else {
-                result.warnings.push((
-                    "yarn_berry_node_gyp_unresolved",
+                node_gyp_unresolved.push((
+                    idx,
                     format!(
                         "{name}@{version}: yarn gives the restored registry entry an \
                          implicit `node-gyp` dependency that {rel} no longer resolves; run \
@@ -1010,7 +1013,15 @@ async fn restore_berry(
     if !changed {
         return;
     }
-    crate::formats::yarn::stanzas::merge_same_resolution(&mut blocks, &restored, &mut moved);
+    let merged =
+        crate::formats::yarn::stanzas::merge_same_resolution(&mut blocks, &restored, &mut moved);
+    for (idx, warning) in node_gyp_unresolved {
+        if !merged.contains(&idx) {
+            result
+                .warnings
+                .push(("yarn_berry_node_gyp_unresolved", warning));
+        }
+    }
     if pkg_changed {
         if let (Some(text), Some(value)) = (pkg_text.as_deref(), pkg.as_mut()) {
             if let Some(obj) = value.as_object_mut() {
 
@@ -764,7 +764,7 @@ pub async fn revert_yarn_berry_opts(
                 let mut changed = false;
                 let restored_entries: Vec<String> = lock_recs
                     .iter()
-                    .filter(|rec| rec.kind == KIND_LOCK_ENTRY)
+                    .filter(|rec| rec.kind == KIND_LOCK_ENTRY || rec.kind == KIND_LOCK_ENTRY_PRUNED)
                     .filter_map(|rec| rec.original.as_ref())
                     .filter_map(super::yarn_classic_lock::json_to_lines)
                     .map(|lines| lines.join("\n"))
@@ -792,11 +792,13 @@ pub async fn revert_yarn_berry_opts(
                         .filter(|&i| restored_entries.contains(&doc.stanzas[i]))
                         .collect();
                     let mut moved = Vec::new();
-                    if crate::formats::yarn::stanzas::merge_same_resolution(
+                    if !crate::formats::yarn::stanzas::merge_same_resolution(
                         &mut doc.stanzas,
                         &restored,
                         &mut moved,
-                    ) {
+                    )
+                    .is_empty()
+                    {
                         text = doc.render(&moved);
                     }
                     forget_block_scans();