diff --git a/rewrite-core/src/main/java/org/openrewrite/Cursor.java b/rewrite-core/src/main/java/org/openrewrite/Cursor.java
index 3be9d7c15a3..7ed54841f73 100644
--- a/rewrite-core/src/main/java/org/openrewrite/Cursor.java
+++ b/rewrite-core/src/main/java/org/openrewrite/Cursor.java
@@ -57,7 +57,7 @@ public Cursor getRoot() {
     /**
      * @return true if this cursor is the root of the tree, false otherwise
      */
-    final boolean isRoot() {
+    final public boolean isRoot() {
         return ROOT_VALUE.equals(value);
     }
 
diff --git a/rewrite-yaml/src/main/java/org/openrewrite/yaml/MergeYaml.java b/rewrite-yaml/src/main/java/org/openrewrite/yaml/MergeYaml.java
index 5361955065f..3b1bf9c1355 100644
--- a/rewrite-yaml/src/main/java/org/openrewrite/yaml/MergeYaml.java
+++ b/rewrite-yaml/src/main/java/org/openrewrite/yaml/MergeYaml.java
@@ -84,6 +84,7 @@ public String getDescription() {
     }
 
     final static String FOUND_MATCHING_ELEMENT = "FOUND_MATCHING_ELEMENT";
+    final static String REMOVE_PREFIX = "REMOVE_PREFIX";
 
     @Override
     public TreeVisitor<?, ExecutionContext> getVisitor() {
@@ -96,7 +97,7 @@ public TreeVisitor<?, ExecutionContext> getVisitor() {
                     .map(docs -> {
                         // Any comments will have been put on the parent Document node, preserve by copying to the mapping
                         Yaml.Document doc = docs.getDocuments().get(0);
-                        if(doc.getBlock() instanceof Yaml.Mapping) {
+                        if (doc.getBlock() instanceof Yaml.Mapping) {
                             Yaml.Mapping m = (Yaml.Mapping) doc.getBlock();
                             return m.withEntries(ListUtils.mapFirst(m.getEntries(), entry -> entry.withPrefix(doc.getPrefix())));
                         } else if (doc.getBlock() instanceof Yaml.Sequence) {
@@ -110,9 +111,11 @@ public TreeVisitor<?, ExecutionContext> getVisitor() {
             @Override
             public Yaml.Document visitDocument(Yaml.Document document, ExecutionContext ctx) {
                 if ("$".equals(key)) {
-                    return document.withBlock((Yaml.Block) new MergeYamlVisitor<>(document.getBlock(), yaml,
-                            Boolean.TRUE.equals(acceptTheirs), objectIdentifyingProperty).visitNonNull(document.getBlock(),
-                            ctx, getCursor()));
+                    Yaml.Document d = document.withBlock((Yaml.Block)
+                            new MergeYamlVisitor<>(document.getBlock(), yaml, Boolean.TRUE.equals(acceptTheirs), objectIdentifyingProperty)
+                                    .visitNonNull(document.getBlock(), ctx, getCursor())
+                    );
+                    return getCursor().getMessage(REMOVE_PREFIX, false) ? d.withEnd(d.getEnd().withPrefix("")) : d;
                 }
                 Yaml.Document d = super.visitDocument(document, ctx);
                 if (d == document && !getCursor().getMessage(FOUND_MATCHING_ELEMENT, false)) {
diff --git a/rewrite-yaml/src/main/java/org/openrewrite/yaml/MergeYamlVisitor.java b/rewrite-yaml/src/main/java/org/openrewrite/yaml/MergeYamlVisitor.java
index 66a5f310506..e3d24a32898 100644
--- a/rewrite-yaml/src/main/java/org/openrewrite/yaml/MergeYamlVisitor.java
+++ b/rewrite-yaml/src/main/java/org/openrewrite/yaml/MergeYamlVisitor.java
@@ -15,23 +15,47 @@
  */
 package org.openrewrite.yaml;
 
-import lombok.AllArgsConstructor;
 import lombok.RequiredArgsConstructor;
 import org.intellij.lang.annotations.Language;
 import org.jspecify.annotations.Nullable;
 import org.openrewrite.Cursor;
 import org.openrewrite.internal.ListUtils;
+import org.openrewrite.style.GeneralFormatStyle;
 import org.openrewrite.yaml.tree.Yaml;
+import org.openrewrite.yaml.tree.Yaml.Document;
+import org.openrewrite.yaml.tree.Yaml.Mapping;
+import org.openrewrite.yaml.tree.Yaml.Mapping.Entry;
+import org.openrewrite.yaml.tree.Yaml.Scalar;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Optional;
+import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 
-@AllArgsConstructor
+import static java.lang.System.lineSeparator;
+import static org.openrewrite.Cursor.ROOT_VALUE;
+import static org.openrewrite.internal.ListUtils.*;
+import static org.openrewrite.yaml.MergeYaml.REMOVE_PREFIX;
+/**
+ * Visitor class to merge two yaml files.
+ *
+ * @implNote Loops recursively through the documents, for every part a new MergeYamlVisitor instance will be created.
+ * As inline comments are put on the prefix of the next element (which can be an item very much higher in the tree),
+ * the following solutions are chosen to merge the comments as well:
+ * <ul>
+ * <li>when an element has new items, the comment of the next element is copied to the previous element
+ * <li>the original comment will be removed (either by traversing the children or by using cursor messages)
+ *
+ * @param <P> An input object that is passed to every visit method.
+ */
 @RequiredArgsConstructor
 public class MergeYamlVisitor<P> extends YamlVisitor<P> {
-    private final Yaml scope;
+
+    private static final Pattern LINE_BREAK = Pattern.compile("\\R");
+
+    private final Yaml existing;
     private final Yaml incoming;
     private final boolean acceptTheirs;
 
@@ -40,6 +64,24 @@ public class MergeYamlVisitor<P> extends YamlVisitor<P> {
 
     private boolean shouldAutoFormat = true;
 
+    public MergeYamlVisitor(Yaml.Block block, Yaml incoming, boolean acceptTheirs, @Nullable String objectIdentifyingProperty, boolean shouldAutoFormat) {
+        this(block, incoming, acceptTheirs, objectIdentifyingProperty);
+        this.shouldAutoFormat = shouldAutoFormat;
+    }
+
+    @Nullable
+    private String linebreak = null;
+
+    private String linebreak() {
+        if (linebreak == null) {
+            linebreak = Optional.ofNullable(getCursor().firstEnclosing(Yaml.Documents.class))
+                    .map(docs -> docs.getStyle(GeneralFormatStyle.class))
+                    .map(format -> format.isUseCRLFNewLines() ? "\r\n" : "\n")
+                    .orElse("\n");
+        }
+        return linebreak;
+    }
+
     public MergeYamlVisitor(Yaml scope, @Language("yml") String yamlString, boolean acceptTheirs, @Nullable String objectIdentifyingProperty) {
         this(scope,
                 new YamlParser().parse(yamlString)
@@ -47,8 +89,8 @@ public MergeYamlVisitor(Yaml scope, @Language("yml") String yamlString, boolean
                         .map(Yaml.Documents.class::cast)
                         .map(docs -> {
                             // Any comments will have been put on the parent Document node, preserve by copying to the mapping
-                            Yaml.Document doc = docs.getDocuments().get(0);
-                            if(doc.getBlock() instanceof Yaml.Mapping) {
+                            Document doc = docs.getDocuments().get(0);
+                            if (doc.getBlock() instanceof Yaml.Mapping) {
                                 Yaml.Mapping m = (Yaml.Mapping) doc.getBlock();
                                 return m.withEntries(ListUtils.mapFirst(m.getEntries(), entry -> entry.withPrefix(doc.getPrefix())));
                             } else if (doc.getBlock() instanceof Yaml.Sequence) {
@@ -64,7 +106,7 @@ public MergeYamlVisitor(Yaml scope, @Language("yml") String yamlString, boolean
 
     @Override
     public Yaml visitScalar(Yaml.Scalar existingScalar, P p) {
-        if (scope.isScope(existingScalar) && incoming instanceof Yaml.Scalar) {
+        if (existing.isScope(existingScalar) && incoming instanceof Yaml.Scalar) {
             return mergeScalar(existingScalar, (Yaml.Scalar) incoming);
         }
         return super.visitScalar(existingScalar, p);
@@ -72,15 +114,15 @@ public Yaml visitScalar(Yaml.Scalar existingScalar, P p) {
 
     @Override
     public Yaml visitSequence(Yaml.Sequence existingSeq, P p) {
-        if (scope.isScope(existingSeq)) {
+        if (existing.isScope(existingSeq)) {
             if (incoming instanceof Yaml.Mapping) {
                 // Distribute the incoming mapping to each entry in the sequence
-                return existingSeq.withEntries(ListUtils.map(existingSeq.getEntries(), (i, existingSeqEntry) -> {
-                    Yaml.Block b = (Yaml.Block) new MergeYamlVisitor<>(existingSeqEntry.getBlock(), incoming,
-                            acceptTheirs, objectIdentifyingProperty, shouldAutoFormat)
-                            .visitNonNull(existingSeqEntry.getBlock(), p, new Cursor(getCursor(), existingSeqEntry));
-                    return existingSeqEntry.withBlock(b);
-                }));
+                return existingSeq.withEntries(map(existingSeq.getEntries(), (i, existingSeqEntry) ->
+                        existingSeqEntry.withBlock((Yaml.Block)
+                                new MergeYamlVisitor<>(existingSeqEntry.getBlock(), incoming, acceptTheirs, objectIdentifyingProperty, shouldAutoFormat)
+                                        .visitNonNull(existingSeqEntry.getBlock(), p, new Cursor(getCursor(), existingSeqEntry))
+                        )
+                ));
             } else if (incoming instanceof Yaml.Sequence) {
                 return mergeSequence(existingSeq, (Yaml.Sequence) incoming, p, getCursor());
             }
@@ -90,14 +132,21 @@ public Yaml visitSequence(Yaml.Sequence existingSeq, P p) {
 
     @Override
     public Yaml visitMapping(Yaml.Mapping existingMapping, P p) {
-        if (scope.isScope(existingMapping) && incoming instanceof Yaml.Mapping) {
-            return mergeMapping(existingMapping, (Yaml.Mapping) incoming, p, getCursor());
+        if (existing.isScope(existingMapping) && incoming instanceof Yaml.Mapping) {
+            Yaml.Mapping mapping = mergeMapping(existingMapping, (Yaml.Mapping) incoming, p, getCursor());
+
+            if (getCursor().getMessage(REMOVE_PREFIX, false)) {
+                List<Yaml.Mapping.Entry> entries = ((Yaml.Mapping) getCursor().getValue()).getEntries();
+                return mapping.withEntries(mapLast(mapping.getEntries(), it -> it.withPrefix(linebreak() + grabAfterFirstLineBreak(entries.get(entries.size() - 1)))));
+            }
+
+            return mapping;
         }
         return super.visitMapping(existingMapping, p);
     }
 
-    private static boolean keyMatches(Yaml.Mapping.Entry e1, Yaml.Mapping.Entry e2) {
-        return e1.getKey().getValue().equals(e2.getKey().getValue());
+    private static boolean keyMatches(Yaml.Mapping.@Nullable Entry e1, Yaml.Mapping.@Nullable Entry e2) {
+        return e1 != null && e2 != null && e1.getKey().getValue().equals(e2.getKey().getValue());
     }
 
     private boolean keyMatches(Yaml.Mapping m1, Yaml.Mapping m2) {
@@ -113,33 +162,92 @@ private boolean keyMatches(Yaml.Mapping m1, Yaml.Mapping m2) {
                 .orElse(false);
     }
 
-    private Yaml.Mapping mergeMapping(Yaml.Mapping m1, Yaml.Mapping m2, P p, Cursor cursor) {
-        List<Yaml.Mapping.Entry> mutatedEntries = ListUtils.map(m1.getEntries(), existingEntry -> {
-            for (Yaml.Mapping.Entry incomingEntry : m2.getEntries()) {
+    private Mapping mergeMapping(Yaml.Mapping m1, Yaml.Mapping m2, P p, Cursor cursor) {
+        List<Yaml.Mapping.Entry> mergedEntries = map(m1.getEntries(), existingEntry -> {
+            for (Entry incomingEntry : m2.getEntries()) {
                 if (keyMatches(existingEntry, incomingEntry)) {
-                    return existingEntry.withValue((Yaml.Block) new MergeYamlVisitor<>(existingEntry.getValue(),
-                            incomingEntry.getValue(), acceptTheirs, objectIdentifyingProperty, shouldAutoFormat)
-                            .visitNonNull(existingEntry.getValue(), p, new Cursor(cursor, existingEntry)));
+                    return existingEntry.withValue((Yaml.Block)
+                            new MergeYamlVisitor<>(existingEntry.getValue(), incomingEntry.getValue(), acceptTheirs, objectIdentifyingProperty, shouldAutoFormat)
+                                    .visitNonNull(existingEntry.getValue(), p, new Cursor(cursor, existingEntry)));
                 }
             }
             return existingEntry;
         });
 
-        mutatedEntries = ListUtils.concatAll(mutatedEntries, ListUtils.map(m2.getEntries(), incomingEntry -> {
-            for (Yaml.Mapping.Entry existingEntry : m1.getEntries()) {
-                if (keyMatches(existingEntry, incomingEntry)) {
+        List<Entry> mutatedEntries = concatAll(mergedEntries, map(m2.getEntries(), it -> {
+            for (Entry existingEntry : m1.getEntries()) {
+                if (keyMatches(existingEntry, it)) {
                     return null;
                 }
             }
-            if (shouldAutoFormat) {
-                incomingEntry = autoFormat(incomingEntry, p, cursor);
+            // workaround: autoFormat cannot handle new inserted values very well
+            if (!mergedEntries.isEmpty() && it.getValue() instanceof Yaml.Scalar && hasLineBreak(mergedEntries.get(0), 2)) {
+                return it.withPrefix(linebreak() + grabAfterFirstLineBreak(mergedEntries.get(0)));
             }
-            return incomingEntry;
+            return shouldAutoFormat ? autoFormat(it, p, cursor) : it;
         }));
 
+        if (m1.getEntries().size() < mutatedEntries.size() && !getCursor().isRoot()) {
+            Cursor c = getCursor().dropParentUntil(it -> {
+                if (ROOT_VALUE.equals(it) || it instanceof Document) {
+                    return true;
+                }
+
+                if (it instanceof Yaml.Mapping) {
+                    List<Yaml.Mapping.Entry> entries = ((Yaml.Mapping) it).getEntries();
+                    // last member should search further upwards until two entries are found
+                    if (entries.get(entries.size() - 1).equals(getCursor().getParentOrThrow().getValue())) {
+                        return false;
+                    }
+                    return entries.size() > 1;
+                }
+
+                return false;
+            });
+
+            if (c.getValue() instanceof Document || c.getValue() instanceof Yaml.Mapping) {
+                String comment = null;
+
+                if (c.getValue() instanceof Document) {
+                    comment = ((Document) c.getValue()).getEnd().getPrefix();
+                } else {
+                    List<Yaml.Mapping.Entry> entries = ((Yaml.Mapping) c.getValue()).getEntries();
+
+                    // get comment from next element in same mapping block
+                    for (int i = 0; i < entries.size() - 1; i++) {
+                        if (entries.get(i).getValue().equals(getCursor().getValue())) {
+                            comment = grabBeforeFirstLineBreak(entries.get(i + 1));
+                            break;
+                        }
+                    }
+                    // or retrieve it for last item from next element (could potentially be much higher in the tree)
+                    if (comment == null && hasLineBreak(entries.get(entries.size() - 1), 1)) {
+                        comment = grabBeforeFirstLineBreak(entries.get(entries.size() - 1));
+                    }
+                }
+
+                if (comment != null) {
+                    Yaml.Mapping.Entry last = mutatedEntries.get(mutatedEntries.size() - 1);
+                    mutatedEntries.set(mutatedEntries.size() - 1, last.withPrefix(comment + last.getPrefix()));
+                    c.putMessage(REMOVE_PREFIX, true);
+                }
+            }
+        }
+
+        removePrefixForDirectChildren(m1.getEntries(), mutatedEntries);
+
         return m1.withEntries(mutatedEntries);
     }
 
+    private void removePrefixForDirectChildren(List<Yaml.Mapping.Entry> m1Entries, List<Yaml.Mapping.Entry> mutatedEntries) {
+        for (int i = 0; i < m1Entries.size() - 1; i++) {
+            if (m1Entries.get(i).getValue() instanceof Yaml.Mapping && mutatedEntries.get(i).getValue() instanceof Yaml.Mapping &&
+                    ((Yaml.Mapping) m1Entries.get(i).getValue()).getEntries().size() < ((Yaml.Mapping) mutatedEntries.get(i).getValue()).getEntries().size()) {
+                mutatedEntries.set(i + 1, mutatedEntries.get(i + 1).withPrefix(linebreak() + grabAfterFirstLineBreak(mutatedEntries.get(i + 1))));
+            }
+        }
+    }
+
     private Yaml.Sequence mergeSequence(Yaml.Sequence s1, Yaml.Sequence s2, P p, Cursor cursor) {
         if (acceptTheirs) {
             return s1;
@@ -163,22 +271,20 @@ private Yaml.Sequence mergeSequence(Yaml.Sequence s1, Yaml.Sequence s2, P p, Cur
                 }
             }
 
-            return s1.withEntries(ListUtils.concatAll(s1.getEntries(),
-                    ListUtils.map(incomingEntries, incomingEntry -> autoFormat(incomingEntry, p, cursor))));
+            return s1.withEntries(concatAll(s1.getEntries(), map(incomingEntries, it -> autoFormat(it, p, cursor))));
         } else {
             if (objectIdentifyingProperty == null) {
                 // No identifier set to match entries on, so cannot continue
                 return s1;
             } else {
-                List<Yaml.Sequence.Entry> mutatedEntries = ListUtils.map(s2.getEntries(), entry -> {
+                List<Yaml.Sequence.Entry> mutatedEntries = map(s2.getEntries(), entry -> {
                     Yaml.Mapping incomingMapping = (Yaml.Mapping) entry.getBlock();
                     for (Yaml.Sequence.Entry existingEntry : s1.getEntries()) {
                         Yaml.Mapping existingMapping = (Yaml.Mapping) existingEntry.getBlock();
                         if (keyMatches(existingMapping, incomingMapping)) {
                             Yaml.Sequence.Entry e1 = existingEntry.withBlock(mergeMapping(existingMapping, incomingMapping, p, cursor));
-                            if(e1 == existingEntry) {
+                            if (e1 == existingEntry) {
                                 // Made no change, no need to consider the entry "mutated"
-                                //noinspection DataFlowIssue
                                 return null;
                             }
                             return e1;
@@ -190,10 +296,9 @@ private Yaml.Sequence mergeSequence(Yaml.Sequence s1, Yaml.Sequence s2, P p, Cur
                     return s1;
                 }
 
-                List<Yaml.Sequence.Entry> entries = ListUtils.concatAll(
-                        s1.getEntries().stream().filter(entry -> !mutatedEntries.contains(entry))
-                                .collect(Collectors.toList()),
-                        ListUtils.map(mutatedEntries, entry -> autoFormat(entry, p, cursor)));
+                List<Yaml.Sequence.Entry> entries = concatAll(
+                        s1.getEntries().stream().filter(entry -> !mutatedEntries.contains(entry)).collect(Collectors.toList()),
+                        map(mutatedEntries, entry -> autoFormat(entry, p, cursor)));
 
                 if (entries.size() != s1.getEntries().size()) {
                     return s1.withEntries(entries);
@@ -208,7 +313,21 @@ private Yaml.Sequence mergeSequence(Yaml.Sequence s1, Yaml.Sequence s2, P p, Cur
         }
     }
 
-    private Yaml.Scalar mergeScalar(Yaml.Scalar y1, Yaml.Scalar y2) {
+    private boolean hasLineBreak(Yaml.Mapping.Entry entry, int atLeastParts) {
+        return LINE_BREAK.matcher(entry.getPrefix()).find() && LINE_BREAK.split(entry.getPrefix()).length >= atLeastParts;
+    }
+
+    private String grabBeforeFirstLineBreak(Yaml.Mapping.Entry entry) {
+        String[] parts = LINE_BREAK.split(entry.getPrefix());
+        return parts.length > 0 ? parts[0] : "";
+    }
+
+    private String grabAfterFirstLineBreak(Yaml.Mapping.Entry entry) {
+        String[] parts = LINE_BREAK.split(entry.getPrefix());
+        return parts.length > 1 ? String.join(linebreak(), Arrays.copyOfRange(parts, 1, parts.length)) : "";
+    }
+
+    private Scalar mergeScalar(Yaml.Scalar y1, Yaml.Scalar y2) {
         String s1 = y1.getValue();
         String s2 = y2.getValue();
         return !s1.equals(s2) && !acceptTheirs ? y1.withValue(s2) : y1;
diff --git a/rewrite-yaml/src/main/java/org/openrewrite/yaml/YamlParser.java b/rewrite-yaml/src/main/java/org/openrewrite/yaml/YamlParser.java
index 047c91789a8..ca7685f37ba 100644
--- a/rewrite-yaml/src/main/java/org/openrewrite/yaml/YamlParser.java
+++ b/rewrite-yaml/src/main/java/org/openrewrite/yaml/YamlParser.java
@@ -82,8 +82,9 @@ public Stream<SourceFile> parseInputs(Iterable<Input> sourceFiles, @Nullable Pat
                         Yaml.Documents docs = (Yaml.Documents) sourceFile;
                         // ensure there is always at least one Document, even in an empty yaml file
                         if (docs.getDocuments().isEmpty()) {
-                            return docs.withDocuments(singletonList(new Yaml.Document(randomId(), "", Markers.EMPTY,
-                                    false, new Yaml.Mapping(randomId(), Markers.EMPTY, null, emptyList(), null, null), null)));
+                            Yaml.Document.End end = new Yaml.Document.End(randomId(), "", Markers.EMPTY, false);
+                            Yaml.Mapping mapping = new Yaml.Mapping(randomId(), Markers.EMPTY, null, emptyList(), null, null);
+                            return docs.withDocuments(singletonList(new Yaml.Document(randomId(), "", Markers.EMPTY, false, mapping, end)));
                         }
                         return docs;
                     }
@@ -157,7 +158,7 @@ private Yaml.Documents parseFromInput(Path sourceFile, EncodingDetectingInputStr
                                 Markers.EMPTY,
                                 ((DocumentStartEvent) event).getExplicit(),
                                 new Yaml.Mapping(randomId(), Markers.EMPTY, null, emptyList(), null, null),
-                                null
+                                new Yaml.Document.End(randomId(), "", Markers.EMPTY, false)
                         );
                         lastEnd = event.getEndMark().getIndex();
                         break;
diff --git a/rewrite-yaml/src/main/java/org/openrewrite/yaml/tree/Yaml.java b/rewrite-yaml/src/main/java/org/openrewrite/yaml/tree/Yaml.java
index a92c0370e54..5245d9ab397 100755
--- a/rewrite-yaml/src/main/java/org/openrewrite/yaml/tree/Yaml.java
+++ b/rewrite-yaml/src/main/java/org/openrewrite/yaml/tree/Yaml.java
@@ -153,7 +153,7 @@ public Document copyPaste() {
                     Markers.EMPTY,
                     explicit,
                     block.copyPaste(),
-                    end == null ? null : end.copyPaste()
+                    end.copyPaste()
             );
         }
 
diff --git a/rewrite-yaml/src/test/java/org/openrewrite/yaml/MergeYamlTest.java b/rewrite-yaml/src/test/java/org/openrewrite/yaml/MergeYamlTest.java
index fd8bba68811..0e6caad72d6 100644
--- a/rewrite-yaml/src/test/java/org/openrewrite/yaml/MergeYamlTest.java
+++ b/rewrite-yaml/src/test/java/org/openrewrite/yaml/MergeYamlTest.java
@@ -1010,6 +1010,205 @@ void mergeSequenceMapChangeComplexMapping() {
         );
     }
 
+    @Issue("https://github.com/openrewrite/rewrite/issues/2218")
+    @Test
+    void existingEntryBlockWithCommentAtFirstLine() {
+        rewriteRun(
+          spec -> spec.recipe(new MergeYaml(
+            "$",
+            //language=yaml
+            """
+              A:
+                B:
+                  C:
+                    D:
+                      4: new desc
+                    D2:
+                      2: new description
+                    D3:
+                      2: new text
+                      3: more new text
+                  E: description
+              """,
+            false,
+            null,
+            null
+          )),
+          yaml(
+            """
+              A: # Comment untouched
+                B:
+                  C:
+                    D:
+                      1: something else
+                      2: something else
+                      3: old desc
+                    D2:
+                      1: old description
+                    D3:
+                      1: old text
+              """,
+            """
+              A: # Comment untouched
+                B:
+                  C:
+                    D:
+                      1: something else
+                      2: something else
+                      3: old desc
+                      4: new desc
+                    D2:
+                      1: old description
+                      2: new description
+                    D3:
+                      1: old text
+                      2: new text
+                      3: more new text
+                  E: description
+              """
+          )
+        );
+    }
+
+    @Issue("https://github.com/openrewrite/rewrite/issues/2218")
+    @Test
+    void existingEntryBlockWithCommentAtLastLine() {
+        rewriteRun(
+          spec -> spec.recipe(new MergeYaml(
+            "$",
+            //language=yaml
+            """
+              spring:
+                application:
+                  description: a description
+              """,
+            false,
+            null,
+            null
+          )),
+          yaml(
+            """
+              spring:
+                application:
+                  name: main # Comment moved from root to previous element
+              """,
+            """
+              spring:
+                application:
+                  name: main # Comment moved from root to previous element
+                  description: a description
+              """
+          )
+        );
+    }
+
+    @Issue("https://github.com/openrewrite/rewrite/issues/2218")
+    @Test
+    void existingEntryBlockWithCommentsAllOverThePlace() {
+        rewriteRun(
+          spec -> spec.recipe(new MergeYaml(
+            "$",
+            //language=yaml
+            """
+              A:
+                B:
+                  C:
+                    D:
+                      3: new desc
+                    D2:
+                      4: d
+                    D3:
+                      2: new description
+                    D4:
+                      2: new text
+              """,
+            false,
+            null,
+            null
+          )),
+          yaml(
+            """
+              A: # Comment untouched 1
+                B: # Comment untouched 2
+                  C: # Comment untouched 3
+                    D: # Comment untouched 4
+                      1: something else
+                      2: old desc # Comment moved from prefix D2 to prefix D->3
+                                  # This is also part of prefix D2, but should NOT be moved to D->3
+                    D2:
+                      1: a
+                      # Comment above tag untouched 1
+                      2: b                             # Comment with a lot of spaces untouched 5
+                      3: c
+                    # Comment above tag untouched 2
+              # with multilines
+                    D3: # Comment untouched 6
+                      1: old description                           # Comment with a lot of spaces moved from prefix D4 to prefix D3->2
+                    D4: # Comment untouched 7
+                      1: old text # Comment moved from end document to prefix D4->2
+              """,
+            """
+              A: # Comment untouched 1
+                B: # Comment untouched 2
+                  C: # Comment untouched 3
+                    D: # Comment untouched 4
+                      1: something else
+                      2: old desc # Comment moved from prefix D2 to prefix D->3
+                      3: new desc
+                                  # This is also part of prefix D2, but should NOT be moved to D->3
+                    D2:
+                      1: a
+                      # Comment above tag untouched 1
+                      2: b                             # Comment with a lot of spaces untouched 5
+                      3: c
+                      4: d
+                    # Comment above tag untouched 2
+              # with multilines
+                    D3: # Comment untouched 6
+                      1: old description                           # Comment with a lot of spaces moved from prefix D4 to prefix D3->2
+                      2: new description
+                    D4: # Comment untouched 7
+                      1: old text # Comment moved from end document to prefix D4->2
+                      2: new text
+              """
+          )
+        );
+    }
+
+    @Issue("https://github.com/openrewrite/rewrite/issues/2218")
+    @Test
+    void existingEntryBlockWithCommentNotAtLastLine() {
+        rewriteRun(
+          spec -> spec.recipe(new MergeYaml(
+            "$",
+            //language=yaml
+            """
+              spring:
+                application:
+                  description: a description
+              """,
+            false,
+            null,
+            null
+          )),
+          yaml(
+            """
+              spring:
+                application:
+                  name: main # Some comment
+                  name2: main
+              """,
+            """
+              spring:
+                application:
+                  name: main # Some comment
+                  name2: main
+                  description: a description
+              """
+          )
+        );
+    }
+
     @Test
     void mergeScalar() {
         rewriteRun(