diff --git a/crates/editor/src/display_map.rs b/crates/editor/src/display_map.rs
index 71b6c72a3d..77357616d9 100644
--- a/crates/editor/src/display_map.rs
+++ b/crates/editor/src/display_map.rs
@@ -33,7 +33,7 @@ pub struct DisplayMap {
     tab_map: TabMap,
     wrap_map: ModelHandle<WrapMap>,
     block_map: BlockMap,
-    edits_since_sync: Mutex<Patch<usize>>,
+    buffer_edits_since_sync: Mutex<Patch<usize>>,
 }
 
 impl Entity for DisplayMap {
@@ -49,7 +49,7 @@ impl DisplayMap {
         wrap_width: Option<f32>,
         cx: &mut ModelContext<Self>,
     ) -> Self {
-        let (fold_map, snapshot) = FoldMap::new(buffer.clone(), cx);
+        let (fold_map, snapshot) = FoldMap::new(buffer.read(cx).snapshot());
         let (tab_map, snapshot) = TabMap::new(snapshot, tab_size);
         let (wrap_map, snapshot) = WrapMap::new(snapshot, font_id, font_size, wrap_width, cx);
         let block_map = BlockMap::new(buffer.clone(), snapshot);
@@ -61,14 +61,15 @@ impl DisplayMap {
             tab_map,
             wrap_map,
             block_map,
-            edits_since_sync: Default::default(),
+            buffer_edits_since_sync: Default::default(),
         }
     }
 
     pub fn snapshot(&self, cx: &mut ModelContext<Self>) -> DisplayMapSnapshot {
+        let buffer_snapshot = self.buffer.read(cx).snapshot();
         let (folds_snapshot, edits) = self.fold_map.read(
-            mem::take(&mut *self.edits_since_sync.lock()).into_inner(),
-            cx,
+            buffer_snapshot,
+            mem::take(&mut *self.buffer_edits_since_sync.lock()).into_inner(),
         );
         let (tabs_snapshot, edits) = self.tab_map.sync(folds_snapshot.clone(), edits);
         let (wraps_snapshot, edits) = self
@@ -90,16 +91,17 @@ impl DisplayMap {
         ranges: impl IntoIterator<Item = Range<T>>,
         cx: &mut ModelContext<Self>,
     ) {
+        let snapshot = self.buffer.read(cx).snapshot();
         let (mut fold_map, snapshot, edits) = self.fold_map.write(
-            mem::take(&mut *self.edits_since_sync.lock()).into_inner(),
-            cx,
+            snapshot,
+            mem::take(&mut *self.buffer_edits_since_sync.lock()).into_inner(),
         );
         let (snapshot, edits) = self.tab_map.sync(snapshot, edits);
         let (snapshot, edits) = self
             .wrap_map
             .update(cx, |map, cx| map.sync(snapshot, edits, cx));
         self.block_map.read(snapshot, edits, cx);
-        let (snapshot, edits) = fold_map.fold(ranges, cx);
+        let (snapshot, edits) = fold_map.fold(ranges);
         let (snapshot, edits) = self.tab_map.sync(snapshot, edits);
         let (snapshot, edits) = self
             .wrap_map
@@ -112,16 +114,17 @@ impl DisplayMap {
         ranges: impl IntoIterator<Item = Range<T>>,
         cx: &mut ModelContext<Self>,
     ) {
+        let snapshot = self.buffer.read(cx).snapshot();
         let (mut fold_map, snapshot, edits) = self.fold_map.write(
-            mem::take(&mut *self.edits_since_sync.lock()).into_inner(),
-            cx,
+            snapshot,
+            mem::take(&mut *self.buffer_edits_since_sync.lock()).into_inner(),
         );
         let (snapshot, edits) = self.tab_map.sync(snapshot, edits);
         let (snapshot, edits) = self
             .wrap_map
             .update(cx, |map, cx| map.sync(snapshot, edits, cx));
         self.block_map.read(snapshot, edits, cx);
-        let (snapshot, edits) = fold_map.unfold(ranges, cx);
+        let (snapshot, edits) = fold_map.unfold(ranges);
         let (snapshot, edits) = self.tab_map.sync(snapshot, edits);
         let (snapshot, edits) = self
             .wrap_map
@@ -138,9 +141,10 @@ impl DisplayMap {
         P: ToOffset + Clone,
         T: Into<Rope> + Clone,
     {
+        let snapshot = self.buffer.read(cx).snapshot();
         let (snapshot, edits) = self.fold_map.read(
-            mem::take(&mut *self.edits_since_sync.lock()).into_inner(),
-            cx,
+            snapshot,
+            mem::take(&mut *self.buffer_edits_since_sync.lock()).into_inner(),
         );
         let (snapshot, edits) = self.tab_map.sync(snapshot, edits);
         let (snapshot, edits) = self
@@ -159,9 +163,10 @@ impl DisplayMap {
     }
 
     pub fn remove_blocks(&mut self, ids: HashSet<BlockId>, cx: &mut ModelContext<Self>) {
+        let snapshot = self.buffer.read(cx).snapshot();
         let (snapshot, edits) = self.fold_map.read(
-            mem::take(&mut *self.edits_since_sync.lock()).into_inner(),
-            cx,
+            snapshot,
+            mem::take(&mut *self.buffer_edits_since_sync.lock()).into_inner(),
         );
         let (snapshot, edits) = self.tab_map.sync(snapshot, edits);
         let (snapshot, edits) = self
@@ -194,13 +199,9 @@ impl DisplayMap {
     ) {
         match event {
             language::Event::Edited(patch) => {
-                self.fold_map.version += 1;
-                let mut edits_since_sync = self.edits_since_sync.lock();
+                let mut edits_since_sync = self.buffer_edits_since_sync.lock();
                 *edits_since_sync = edits_since_sync.compose(patch);
             }
-            language::Event::Reparsed | language::Event::DiagnosticsUpdated => {
-                self.fold_map.version += 1;
-            }
             _ => {}
         }
     }
@@ -563,7 +564,7 @@ mod tests {
                     }
                 }
                 _ => {
-                    buffer.update(&mut cx, |buffer, _| buffer.randomly_edit(&mut rng, 5));
+                    buffer.update(&mut cx, |buffer, cx| buffer.randomly_edit(&mut rng, 5, cx));
                 }
             }
 
diff --git a/crates/editor/src/display_map/block_map.rs b/crates/editor/src/display_map/block_map.rs
index 0800f8d1e7..5ed1ac65fb 100644
--- a/crates/editor/src/display_map/block_map.rs
+++ b/crates/editor/src/display_map/block_map.rs
@@ -1104,7 +1104,7 @@ mod tests {
         let text = "aaa\nbbb\nccc\nddd";
 
         let buffer = cx.add_model(|cx| Buffer::new(0, text, cx));
-        let (fold_map, folds_snapshot) = FoldMap::new(buffer.clone(), cx);
+        let (fold_map, folds_snapshot) = FoldMap::new(buffer.read(cx).snapshot());
         let (tab_map, tabs_snapshot) = TabMap::new(folds_snapshot.clone(), 1);
         let (wrap_map, wraps_snapshot) = WrapMap::new(tabs_snapshot, font_id, 14.0, None, cx);
         let mut block_map = BlockMap::new(buffer.clone(), wraps_snapshot.clone());
@@ -1228,13 +1228,13 @@ mod tests {
 
         // Insert a line break, separating two block decorations into separate
         // lines.
-        let buffer_edits = buffer.update(cx, |buffer, cx| {
+        let (buffer_snapshot, buffer_edits) = buffer.update(cx, |buffer, cx| {
             let v0 = buffer.version();
             buffer.edit([Point::new(1, 1)..Point::new(1, 1)], "!!!\n", cx);
-            buffer.edits_since(&v0).collect()
+            (buffer.snapshot(), buffer.edits_since(&v0).collect())
         });
 
-        let (folds_snapshot, fold_edits) = fold_map.read(buffer_edits, cx);
+        let (folds_snapshot, fold_edits) = fold_map.read(buffer_snapshot, buffer_edits);
         let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
         let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
             wrap_map.sync(tabs_snapshot, tab_edits, cx)
@@ -1257,7 +1257,7 @@ mod tests {
         let text = "one two three\nfour five six\nseven eight";
 
         let buffer = cx.add_model(|cx| Buffer::new(0, text, cx));
-        let (_, folds_snapshot) = FoldMap::new(buffer.clone(), cx);
+        let (_, folds_snapshot) = FoldMap::new(buffer.read(cx).snapshot());
         let (_, tabs_snapshot) = TabMap::new(folds_snapshot.clone(), 1);
         let (_, wraps_snapshot) = WrapMap::new(tabs_snapshot, font_id, 14.0, Some(60.), cx);
         let mut block_map = BlockMap::new(buffer.clone(), wraps_snapshot.clone());
@@ -1319,7 +1319,8 @@ mod tests {
             log::info!("initial buffer text: {:?}", text);
             Buffer::new(0, text, cx)
         });
-        let (fold_map, folds_snapshot) = FoldMap::new(buffer.clone(), cx);
+        let mut buffer_snapshot = buffer.read(cx).snapshot();
+        let (fold_map, folds_snapshot) = FoldMap::new(buffer_snapshot.clone());
         let (tab_map, tabs_snapshot) = TabMap::new(folds_snapshot.clone(), tab_size);
         let (wrap_map, wraps_snapshot) =
             WrapMap::new(tabs_snapshot, font_id, font_size, wrap_width, cx);
@@ -1378,7 +1379,8 @@ mod tests {
                         })
                         .collect::<Vec<_>>();
 
-                    let (folds_snapshot, fold_edits) = fold_map.read(vec![], cx);
+                    let (folds_snapshot, fold_edits) =
+                        fold_map.read(buffer_snapshot.clone(), vec![]);
                     let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
                     let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
                         wrap_map.sync(tabs_snapshot, tab_edits, cx)
@@ -1399,7 +1401,8 @@ mod tests {
                         })
                         .collect();
 
-                    let (folds_snapshot, fold_edits) = fold_map.read(vec![], cx);
+                    let (folds_snapshot, fold_edits) =
+                        fold_map.read(buffer_snapshot.clone(), vec![]);
                     let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
                     let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
                         wrap_map.sync(tabs_snapshot, tab_edits, cx)
@@ -1408,16 +1411,18 @@ mod tests {
                     block_map.remove(block_ids_to_remove, cx);
                 }
                 _ => {
-                    buffer.update(cx, |buffer, _| {
+                    buffer.update(cx, |buffer, cx| {
                         let v0 = buffer.version();
-                        buffer.randomly_edit(&mut rng, 1);
+                        let edit_count = rng.gen_range(1..=5);
+                        buffer.randomly_edit(&mut rng, edit_count, cx);
                         log::info!("buffer text: {:?}", buffer.text());
                         buffer_edits.extend(buffer.edits_since(&v0));
+                        buffer_snapshot = buffer.snapshot();
                     });
                 }
             }
 
-            let (folds_snapshot, fold_edits) = fold_map.read(buffer_edits, cx);
+            let (folds_snapshot, fold_edits) = fold_map.read(buffer_snapshot.clone(), buffer_edits);
             let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
             let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
                 wrap_map.sync(tabs_snapshot, tab_edits, cx)
diff --git a/crates/editor/src/display_map/fold_map.rs b/crates/editor/src/display_map/fold_map.rs
index 4ca74ad906..0e920c5e6a 100644
--- a/crates/editor/src/display_map/fold_map.rs
+++ b/crates/editor/src/display_map/fold_map.rs
@@ -1,12 +1,13 @@
-use gpui::{AppContext, ModelHandle};
 use language::{
-    Anchor, AnchorRangeExt, Buffer, Chunk, Edit, Point, PointUtf16, TextSummary, ToOffset,
+    Anchor, AnchorRangeExt, Chunk, Edit, Point, PointUtf16, Snapshot as BufferSnapshot,
+    TextSummary, ToOffset,
 };
 use parking_lot::Mutex;
 use std::{
     cmp::{self, Ordering},
     iter,
     ops::Range,
+    sync::atomic::{AtomicUsize, Ordering::SeqCst},
 };
 use sum_tree::{Bias, Cursor, FilterCursor, SumTree};
 use theme::SyntaxTheme;
@@ -101,11 +102,10 @@ impl<'a> FoldMapWriter<'a> {
     pub fn fold<T: ToOffset>(
         &mut self,
         ranges: impl IntoIterator<Item = Range<T>>,
-        cx: &AppContext,
     ) -> (Snapshot, Vec<FoldEdit>) {
         let mut edits = Vec::new();
         let mut folds = Vec::new();
-        let buffer = self.0.buffer.read(cx).snapshot();
+        let buffer = self.0.buffer.lock().clone();
         for range in ranges.into_iter() {
             let range = range.start.to_offset(&buffer)..range.end.to_offset(&buffer);
             if range.start != range.end {
@@ -132,12 +132,12 @@ impl<'a> FoldMapWriter<'a> {
         };
 
         consolidate_buffer_edits(&mut edits);
-        let edits = self.0.sync(edits, cx);
+        let edits = self.0.sync(buffer.clone(), edits);
         let snapshot = Snapshot {
             transforms: self.0.transforms.lock().clone(),
             folds: self.0.folds.clone(),
-            buffer_snapshot: self.0.buffer.read(cx).snapshot(),
-            version: self.0.version,
+            buffer_snapshot: buffer,
+            version: self.0.version.load(SeqCst),
         };
         (snapshot, edits)
     }
@@ -145,11 +145,10 @@ impl<'a> FoldMapWriter<'a> {
     pub fn unfold<T: ToOffset>(
         &mut self,
         ranges: impl IntoIterator<Item = Range<T>>,
-        cx: &AppContext,
     ) -> (Snapshot, Vec<FoldEdit>) {
         let mut edits = Vec::new();
         let mut fold_ixs_to_delete = Vec::new();
-        let buffer = self.0.buffer.read(cx).snapshot();
+        let buffer = self.0.buffer.lock().clone();
         for range in ranges.into_iter() {
             // Remove intersecting folds and add their ranges to edits that are passed to sync.
             let mut folds_cursor = intersecting_folds(&buffer, &self.0.folds, range, true);
@@ -179,29 +178,28 @@ impl<'a> FoldMapWriter<'a> {
         };
 
         consolidate_buffer_edits(&mut edits);
-        let edits = self.0.sync(edits, cx);
+        let edits = self.0.sync(buffer.clone(), edits);
         let snapshot = Snapshot {
             transforms: self.0.transforms.lock().clone(),
             folds: self.0.folds.clone(),
-            buffer_snapshot: self.0.buffer.read(cx).snapshot(),
-            version: self.0.version,
+            buffer_snapshot: buffer,
+            version: self.0.version.load(SeqCst),
         };
         (snapshot, edits)
     }
 }
 
 pub struct FoldMap {
-    buffer: ModelHandle<Buffer>,
+    buffer: Mutex<BufferSnapshot>,
     transforms: Mutex<SumTree<Transform>>,
     folds: SumTree<Fold>,
-    pub version: usize,
+    version: AtomicUsize,
 }
 
 impl FoldMap {
-    pub fn new(buffer_handle: ModelHandle<Buffer>, cx: &AppContext) -> (Self, Snapshot) {
-        let buffer = buffer_handle.read(cx);
+    pub fn new(buffer: BufferSnapshot) -> (Self, Snapshot) {
         let this = Self {
-            buffer: buffer_handle,
+            buffer: Mutex::new(buffer.clone()),
             folds: Default::default(),
             transforms: Mutex::new(SumTree::from_item(
                 Transform {
@@ -213,124 +211,185 @@ impl FoldMap {
                 },
                 &(),
             )),
-            version: 0,
+            version: Default::default(),
+        };
+
+        let snapshot = Snapshot {
+            transforms: this.transforms.lock().clone(),
+            folds: this.folds.clone(),
+            buffer_snapshot: this.buffer.lock().clone(),
+            version: this.version.load(SeqCst),
         };
-        let (snapshot, _) = this.read(Vec::new(), cx);
         (this, snapshot)
     }
 
-    pub fn read(&self, edits: Vec<Edit<usize>>, cx: &AppContext) -> (Snapshot, Vec<FoldEdit>) {
-        let edits = self.sync(edits, cx);
-        self.check_invariants(cx);
+    pub fn read(
+        &self,
+        buffer: BufferSnapshot,
+        edits: Vec<Edit<usize>>,
+    ) -> (Snapshot, Vec<FoldEdit>) {
+        let edits = self.sync(buffer, edits);
+        self.check_invariants();
         let snapshot = Snapshot {
             transforms: self.transforms.lock().clone(),
             folds: self.folds.clone(),
-            buffer_snapshot: self.buffer.read(cx).snapshot(),
-            version: self.version,
+            buffer_snapshot: self.buffer.lock().clone(),
+            version: self.version.load(SeqCst),
         };
         (snapshot, edits)
     }
 
     pub fn write(
         &mut self,
+        buffer: BufferSnapshot,
         edits: Vec<Edit<usize>>,
-        cx: &AppContext,
     ) -> (FoldMapWriter, Snapshot, Vec<FoldEdit>) {
-        let (snapshot, edits) = self.read(edits, cx);
+        let (snapshot, edits) = self.read(buffer, edits);
         (FoldMapWriter(self), snapshot, edits)
     }
 
-    fn check_invariants(&self, cx: &AppContext) {
+    fn check_invariants(&self) {
         if cfg!(test) {
-            let buffer = self.buffer.read(cx);
             assert_eq!(
                 self.transforms.lock().summary().input.bytes,
-                buffer.len(),
+                self.buffer.lock().len(),
                 "transform tree does not match buffer's length"
             );
         }
     }
 
-    fn sync(&self, buffer_edits: Vec<text::Edit<usize>>, cx: &AppContext) -> Vec<FoldEdit> {
+    fn sync(
+        &self,
+        new_buffer: BufferSnapshot,
+        buffer_edits: Vec<text::Edit<usize>>,
+    ) -> Vec<FoldEdit> {
         if buffer_edits.is_empty() {
-            return Vec::new();
-        }
+            let mut buffer = self.buffer.lock();
+            if buffer.parse_count() != new_buffer.parse_count()
+                || buffer.diagnostics_update_count() != new_buffer.diagnostics_update_count()
+            {
+                self.version.fetch_add(1, SeqCst);
+            }
+            *buffer = new_buffer;
+            Vec::new()
+        } else {
+            let mut buffer_edits_iter = buffer_edits.iter().cloned().peekable();
 
-        let buffer = self.buffer.read(cx).snapshot();
-        let mut buffer_edits_iter = buffer_edits.iter().cloned().peekable();
+            let mut new_transforms = SumTree::new();
+            let mut transforms = self.transforms.lock();
+            let mut cursor = transforms.cursor::<usize>();
+            cursor.seek(&0, Bias::Right, &());
 
-        let mut new_transforms = SumTree::new();
-        let mut transforms = self.transforms.lock();
-        let mut cursor = transforms.cursor::<usize>();
-        cursor.seek(&0, Bias::Right, &());
+            while let Some(mut edit) = buffer_edits_iter.next() {
+                new_transforms.push_tree(cursor.slice(&edit.old.start, Bias::Left, &()), &());
+                edit.new.start -= edit.old.start - cursor.start();
+                edit.old.start = *cursor.start();
 
-        while let Some(mut edit) = buffer_edits_iter.next() {
-            new_transforms.push_tree(cursor.slice(&edit.old.start, Bias::Left, &()), &());
-            edit.new.start -= edit.old.start - cursor.start();
-            edit.old.start = *cursor.start();
+                cursor.seek(&edit.old.end, Bias::Right, &());
+                cursor.next(&());
 
-            cursor.seek(&edit.old.end, Bias::Right, &());
-            cursor.next(&());
+                let mut delta = edit.new.len() as isize - edit.old.len() as isize;
+                loop {
+                    edit.old.end = *cursor.start();
 
-            let mut delta = edit.new.len() as isize - edit.old.len() as isize;
-            loop {
-                edit.old.end = *cursor.start();
+                    if let Some(next_edit) = buffer_edits_iter.peek() {
+                        if next_edit.old.start > edit.old.end {
+                            break;
+                        }
 
-                if let Some(next_edit) = buffer_edits_iter.peek() {
-                    if next_edit.old.start > edit.old.end {
+                        let next_edit = buffer_edits_iter.next().unwrap();
+                        delta += next_edit.new.len() as isize - next_edit.old.len() as isize;
+
+                        if next_edit.old.end >= edit.old.end {
+                            edit.old.end = next_edit.old.end;
+                            cursor.seek(&edit.old.end, Bias::Right, &());
+                            cursor.next(&());
+                        }
+                    } else {
                         break;
                     }
+                }
 
-                    let next_edit = buffer_edits_iter.next().unwrap();
-                    delta += next_edit.new.len() as isize - next_edit.old.len() as isize;
+                edit.new.end = ((edit.new.start + edit.old.len()) as isize + delta) as usize;
 
-                    if next_edit.old.end >= edit.old.end {
-                        edit.old.end = next_edit.old.end;
-                        cursor.seek(&edit.old.end, Bias::Right, &());
-                        cursor.next(&());
+                let anchor = new_buffer.anchor_before(edit.new.start);
+                let mut folds_cursor = self.folds.cursor::<Fold>();
+                folds_cursor.seek(&Fold(anchor..Anchor::max()), Bias::Left, &new_buffer);
+
+                let mut folds = iter::from_fn({
+                    let buffer = &new_buffer;
+                    move || {
+                        let item = folds_cursor
+                            .item()
+                            .map(|f| f.0.start.to_offset(buffer)..f.0.end.to_offset(buffer));
+                        folds_cursor.next(buffer);
+                        item
+                    }
+                })
+                .peekable();
+
+                while folds.peek().map_or(false, |fold| fold.start < edit.new.end) {
+                    let mut fold = folds.next().unwrap();
+                    let sum = new_transforms.summary();
+
+                    assert!(fold.start >= sum.input.bytes);
+
+                    while folds
+                        .peek()
+                        .map_or(false, |next_fold| next_fold.start <= fold.end)
+                    {
+                        let next_fold = folds.next().unwrap();
+                        if next_fold.end > fold.end {
+                            fold.end = next_fold.end;
+                        }
+                    }
+
+                    if fold.start > sum.input.bytes {
+                        let text_summary = new_buffer
+                            .text_summary_for_range::<TextSummary, _>(sum.input.bytes..fold.start);
+                        new_transforms.push(
+                            Transform {
+                                summary: TransformSummary {
+                                    output: text_summary.clone(),
+                                    input: text_summary,
+                                },
+                                output_text: None,
+                            },
+                            &(),
+                        );
+                    }
+
+                    if fold.end > fold.start {
+                        let output_text = "…";
+                        let chars = output_text.chars().count() as u32;
+                        let lines = Point::new(0, output_text.len() as u32);
+                        let lines_utf16 =
+                            PointUtf16::new(0, output_text.encode_utf16().count() as u32);
+                        new_transforms.push(
+                            Transform {
+                                summary: TransformSummary {
+                                    output: TextSummary {
+                                        bytes: output_text.len(),
+                                        lines,
+                                        lines_utf16,
+                                        first_line_chars: chars,
+                                        last_line_chars: chars,
+                                        longest_row: 0,
+                                        longest_row_chars: chars,
+                                    },
+                                    input: new_buffer.text_summary_for_range(fold.start..fold.end),
+                                },
+                                output_text: Some(output_text),
+                            },
+                            &(),
+                        );
                     }
-                } else {
-                    break;
                 }
-            }
 
-            edit.new.end = ((edit.new.start + edit.old.len()) as isize + delta) as usize;
-
-            let anchor = buffer.anchor_before(edit.new.start);
-            let mut folds_cursor = self.folds.cursor::<Fold>();
-            folds_cursor.seek(&Fold(anchor..Anchor::max()), Bias::Left, &buffer);
-
-            let mut folds = iter::from_fn({
-                let buffer = &buffer;
-                move || {
-                    let item = folds_cursor
-                        .item()
-                        .map(|f| f.0.start.to_offset(buffer)..f.0.end.to_offset(buffer));
-                    folds_cursor.next(buffer);
-                    item
-                }
-            })
-            .peekable();
-
-            while folds.peek().map_or(false, |fold| fold.start < edit.new.end) {
-                let mut fold = folds.next().unwrap();
                 let sum = new_transforms.summary();
-
-                assert!(fold.start >= sum.input.bytes);
-
-                while folds
-                    .peek()
-                    .map_or(false, |next_fold| next_fold.start <= fold.end)
-                {
-                    let next_fold = folds.next().unwrap();
-                    if next_fold.end > fold.end {
-                        fold.end = next_fold.end;
-                    }
-                }
-
-                if fold.start > sum.input.bytes {
-                    let text_summary = buffer
-                        .text_summary_for_range::<TextSummary, _>(sum.input.bytes..fold.start);
+                if sum.input.bytes < edit.new.end {
+                    let text_summary = new_buffer
+                        .text_summary_for_range::<TextSummary, _>(sum.input.bytes..edit.new.end);
                     new_transforms.push(
                         Transform {
                             summary: TransformSummary {
@@ -342,37 +401,11 @@ impl FoldMap {
                         &(),
                     );
                 }
-
-                if fold.end > fold.start {
-                    let output_text = "…";
-                    let chars = output_text.chars().count() as u32;
-                    let lines = Point::new(0, output_text.len() as u32);
-                    let lines_utf16 = PointUtf16::new(0, output_text.encode_utf16().count() as u32);
-                    new_transforms.push(
-                        Transform {
-                            summary: TransformSummary {
-                                output: TextSummary {
-                                    bytes: output_text.len(),
-                                    lines,
-                                    lines_utf16,
-                                    first_line_chars: chars,
-                                    last_line_chars: chars,
-                                    longest_row: 0,
-                                    longest_row_chars: chars,
-                                },
-                                input: buffer.text_summary_for_range(fold.start..fold.end),
-                            },
-                            output_text: Some(output_text),
-                        },
-                        &(),
-                    );
-                }
             }
 
-            let sum = new_transforms.summary();
-            if sum.input.bytes < edit.new.end {
-                let text_summary =
-                    buffer.text_summary_for_range::<TextSummary, _>(sum.input.bytes..edit.new.end);
+            new_transforms.push_tree(cursor.suffix(&()), &());
+            if new_transforms.is_empty() {
+                let text_summary = new_buffer.text_summary();
                 new_transforms.push(
                     Transform {
                         summary: TransformSummary {
@@ -384,72 +417,59 @@ impl FoldMap {
                     &(),
                 );
             }
-        }
 
-        new_transforms.push_tree(cursor.suffix(&()), &());
-        if new_transforms.is_empty() {
-            let text_summary = buffer.text_summary();
-            new_transforms.push(
-                Transform {
-                    summary: TransformSummary {
-                        output: text_summary.clone(),
-                        input: text_summary,
-                    },
-                    output_text: None,
-                },
-                &(),
-            );
-        }
+            drop(cursor);
 
-        drop(cursor);
+            let mut fold_edits = Vec::with_capacity(buffer_edits.len());
+            {
+                let mut old_transforms = transforms.cursor::<(usize, FoldOffset)>();
+                let mut new_transforms = new_transforms.cursor::<(usize, FoldOffset)>();
 
-        let mut fold_edits = Vec::with_capacity(buffer_edits.len());
-        {
-            let mut old_transforms = transforms.cursor::<(usize, FoldOffset)>();
-            let mut new_transforms = new_transforms.cursor::<(usize, FoldOffset)>();
+                for mut edit in buffer_edits {
+                    old_transforms.seek(&edit.old.start, Bias::Left, &());
+                    if old_transforms.item().map_or(false, |t| t.is_fold()) {
+                        edit.old.start = old_transforms.start().0;
+                    }
+                    let old_start =
+                        old_transforms.start().1 .0 + (edit.old.start - old_transforms.start().0);
 
-            for mut edit in buffer_edits {
-                old_transforms.seek(&edit.old.start, Bias::Left, &());
-                if old_transforms.item().map_or(false, |t| t.is_fold()) {
-                    edit.old.start = old_transforms.start().0;
+                    old_transforms.seek_forward(&edit.old.end, Bias::Right, &());
+                    if old_transforms.item().map_or(false, |t| t.is_fold()) {
+                        old_transforms.next(&());
+                        edit.old.end = old_transforms.start().0;
+                    }
+                    let old_end =
+                        old_transforms.start().1 .0 + (edit.old.end - old_transforms.start().0);
+
+                    new_transforms.seek(&edit.new.start, Bias::Left, &());
+                    if new_transforms.item().map_or(false, |t| t.is_fold()) {
+                        edit.new.start = new_transforms.start().0;
+                    }
+                    let new_start =
+                        new_transforms.start().1 .0 + (edit.new.start - new_transforms.start().0);
+
+                    new_transforms.seek_forward(&edit.new.end, Bias::Right, &());
+                    if new_transforms.item().map_or(false, |t| t.is_fold()) {
+                        new_transforms.next(&());
+                        edit.new.end = new_transforms.start().0;
+                    }
+                    let new_end =
+                        new_transforms.start().1 .0 + (edit.new.end - new_transforms.start().0);
+
+                    fold_edits.push(FoldEdit {
+                        old_bytes: FoldOffset(old_start)..FoldOffset(old_end),
+                        new_bytes: FoldOffset(new_start)..FoldOffset(new_end),
+                    });
                 }
-                let old_start =
-                    old_transforms.start().1 .0 + (edit.old.start - old_transforms.start().0);
 
-                old_transforms.seek_forward(&edit.old.end, Bias::Right, &());
-                if old_transforms.item().map_or(false, |t| t.is_fold()) {
-                    old_transforms.next(&());
-                    edit.old.end = old_transforms.start().0;
-                }
-                let old_end =
-                    old_transforms.start().1 .0 + (edit.old.end - old_transforms.start().0);
-
-                new_transforms.seek(&edit.new.start, Bias::Left, &());
-                if new_transforms.item().map_or(false, |t| t.is_fold()) {
-                    edit.new.start = new_transforms.start().0;
-                }
-                let new_start =
-                    new_transforms.start().1 .0 + (edit.new.start - new_transforms.start().0);
-
-                new_transforms.seek_forward(&edit.new.end, Bias::Right, &());
-                if new_transforms.item().map_or(false, |t| t.is_fold()) {
-                    new_transforms.next(&());
-                    edit.new.end = new_transforms.start().0;
-                }
-                let new_end =
-                    new_transforms.start().1 .0 + (edit.new.end - new_transforms.start().0);
-
-                fold_edits.push(FoldEdit {
-                    old_bytes: FoldOffset(old_start)..FoldOffset(old_end),
-                    new_bytes: FoldOffset(new_start)..FoldOffset(new_end),
-                });
+                consolidate_fold_edits(&mut fold_edits);
             }
 
-            consolidate_fold_edits(&mut fold_edits);
+            *transforms = new_transforms;
+            *self.buffer.lock() = new_buffer;
+            self.version.fetch_add(1, SeqCst);
+            fold_edits
         }
-
-        *transforms = new_transforms;
-        fold_edits
     }
 }
 
@@ -1045,6 +1065,7 @@ impl FoldEdit {
 mod tests {
     use super::*;
     use crate::{test::sample_text, ToPoint};
+    use language::Buffer;
     use rand::prelude::*;
     use std::{env, mem};
     use text::RandomCharIter;
@@ -1053,16 +1074,14 @@ mod tests {
     #[gpui::test]
     fn test_basic_folds(cx: &mut gpui::MutableAppContext) {
         let buffer = cx.add_model(|cx| Buffer::new(0, sample_text(5, 6), cx));
-        let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
+        let buffer_snapshot = buffer.read(cx).snapshot();
+        let mut map = FoldMap::new(buffer_snapshot.clone()).0;
 
-        let (mut writer, _, _) = map.write(vec![], cx.as_ref());
-        let (snapshot2, edits) = writer.fold(
-            vec![
-                Point::new(0, 2)..Point::new(2, 2),
-                Point::new(2, 4)..Point::new(4, 1),
-            ],
-            cx.as_ref(),
-        );
+        let (mut writer, _, _) = map.write(buffer_snapshot.clone(), vec![]);
+        let (snapshot2, edits) = writer.fold(vec![
+            Point::new(0, 2)..Point::new(2, 2),
+            Point::new(2, 4)..Point::new(4, 1),
+        ]);
         assert_eq!(snapshot2.text(), "aa…cc…eeeee");
         assert_eq!(
             edits,
@@ -1078,7 +1097,7 @@ mod tests {
             ]
         );
 
-        let edits = buffer.update(cx, |buffer, cx| {
+        let (buffer_snapshot, edits) = buffer.update(cx, |buffer, cx| {
             let v0 = buffer.version();
             buffer.edit(
                 vec![
@@ -1088,9 +1107,9 @@ mod tests {
                 "123",
                 cx,
             );
-            buffer.edits_since(&v0).collect()
+            (buffer.snapshot(), buffer.edits_since(&v0).collect())
         });
-        let (snapshot3, edits) = map.read(edits, cx.as_ref());
+        let (snapshot3, edits) = map.read(buffer_snapshot.clone(), edits);
         assert_eq!(snapshot3.text(), "123a…c123c…eeeee");
         assert_eq!(
             edits,
@@ -1106,61 +1125,62 @@ mod tests {
             ]
         );
 
-        let edits = buffer.update(cx, |buffer, cx| {
+        let (buffer_snapshot, edits) = buffer.update(cx, |buffer, cx| {
             let v0 = buffer.version();
             buffer.edit(vec![Point::new(2, 6)..Point::new(4, 3)], "456", cx);
-            buffer.edits_since(&v0).collect()
+            (buffer.snapshot(), buffer.edits_since(&v0).collect())
         });
-        let (snapshot4, _) = map.read(edits, cx.as_ref());
+        let (snapshot4, _) = map.read(buffer_snapshot.clone(), edits);
         assert_eq!(snapshot4.text(), "123a…c123456eee");
 
-        let (mut writer, _, _) = map.write(vec![], cx.as_ref());
-        writer.unfold(Some(Point::new(0, 4)..Point::new(0, 5)), cx.as_ref());
-        let (snapshot5, _) = map.read(vec![], cx.as_ref());
+        let (mut writer, _, _) = map.write(buffer_snapshot.clone(), vec![]);
+        writer.unfold(Some(Point::new(0, 4)..Point::new(0, 5)));
+        let (snapshot5, _) = map.read(buffer_snapshot.clone(), vec![]);
         assert_eq!(snapshot5.text(), "123aaaaa\nbbbbbb\nccc123456eee");
     }
 
     #[gpui::test]
     fn test_adjacent_folds(cx: &mut gpui::MutableAppContext) {
         let buffer = cx.add_model(|cx| Buffer::new(0, "abcdefghijkl", cx));
+        let buffer_snapshot = buffer.read(cx).snapshot();
 
         {
-            let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
+            let mut map = FoldMap::new(buffer_snapshot.clone()).0;
 
-            let (mut writer, _, _) = map.write(vec![], cx.as_ref());
-            writer.fold(vec![5..8], cx.as_ref());
-            let (snapshot, _) = map.read(vec![], cx.as_ref());
+            let (mut writer, _, _) = map.write(buffer_snapshot.clone(), vec![]);
+            writer.fold(vec![5..8]);
+            let (snapshot, _) = map.read(buffer_snapshot.clone(), vec![]);
             assert_eq!(snapshot.text(), "abcde…ijkl");
 
             // Create an fold adjacent to the start of the first fold.
-            let (mut writer, _, _) = map.write(vec![], cx.as_ref());
-            writer.fold(vec![0..1, 2..5], cx.as_ref());
-            let (snapshot, _) = map.read(vec![], cx.as_ref());
+            let (mut writer, _, _) = map.write(buffer_snapshot.clone(), vec![]);
+            writer.fold(vec![0..1, 2..5]);
+            let (snapshot, _) = map.read(buffer_snapshot.clone(), vec![]);
             assert_eq!(snapshot.text(), "…b…ijkl");
 
             // Create an fold adjacent to the end of the first fold.
-            let (mut writer, _, _) = map.write(vec![], cx.as_ref());
-            writer.fold(vec![11..11, 8..10], cx.as_ref());
-            let (snapshot, _) = map.read(vec![], cx.as_ref());
+            let (mut writer, _, _) = map.write(buffer_snapshot.clone(), vec![]);
+            writer.fold(vec![11..11, 8..10]);
+            let (snapshot, _) = map.read(buffer_snapshot.clone(), vec![]);
             assert_eq!(snapshot.text(), "…b…kl");
         }
 
         {
-            let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
+            let mut map = FoldMap::new(buffer_snapshot.clone()).0;
 
             // Create two adjacent folds.
-            let (mut writer, _, _) = map.write(vec![], cx.as_ref());
-            writer.fold(vec![0..2, 2..5], cx.as_ref());
-            let (snapshot, _) = map.read(vec![], cx.as_ref());
+            let (mut writer, _, _) = map.write(buffer_snapshot.clone(), vec![]);
+            writer.fold(vec![0..2, 2..5]);
+            let (snapshot, _) = map.read(buffer_snapshot.clone(), vec![]);
             assert_eq!(snapshot.text(), "…fghijkl");
 
             // Edit within one of the folds.
-            let edits = buffer.update(cx, |buffer, cx| {
+            let (buffer_snapshot, edits) = buffer.update(cx, |buffer, cx| {
                 let v0 = buffer.version();
                 buffer.edit(vec![0..1], "12345", cx);
-                buffer.edits_since(&v0).collect()
+                (buffer.snapshot(), buffer.edits_since(&v0).collect())
             });
-            let (snapshot, _) = map.read(edits, cx.as_ref());
+            let (snapshot, _) = map.read(buffer_snapshot.clone(), edits);
             assert_eq!(snapshot.text(), "12345…fghijkl");
         }
     }
@@ -1168,63 +1188,57 @@ mod tests {
     #[gpui::test]
     fn test_overlapping_folds(cx: &mut gpui::MutableAppContext) {
         let buffer = cx.add_model(|cx| Buffer::new(0, sample_text(5, 6), cx));
-        let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
-        let (mut writer, _, _) = map.write(vec![], cx.as_ref());
-        writer.fold(
-            vec![
-                Point::new(0, 2)..Point::new(2, 2),
-                Point::new(0, 4)..Point::new(1, 0),
-                Point::new(1, 2)..Point::new(3, 2),
-                Point::new(3, 1)..Point::new(4, 1),
-            ],
-            cx.as_ref(),
-        );
-        let (snapshot, _) = map.read(vec![], cx.as_ref());
+        let buffer_snapshot = buffer.read(cx).snapshot();
+        let mut map = FoldMap::new(buffer_snapshot.clone()).0;
+        let (mut writer, _, _) = map.write(buffer_snapshot.clone(), vec![]);
+        writer.fold(vec![
+            Point::new(0, 2)..Point::new(2, 2),
+            Point::new(0, 4)..Point::new(1, 0),
+            Point::new(1, 2)..Point::new(3, 2),
+            Point::new(3, 1)..Point::new(4, 1),
+        ]);
+        let (snapshot, _) = map.read(buffer_snapshot.clone(), vec![]);
         assert_eq!(snapshot.text(), "aa…eeeee");
     }
 
     #[gpui::test]
     fn test_merging_folds_via_edit(cx: &mut gpui::MutableAppContext) {
         let buffer = cx.add_model(|cx| Buffer::new(0, sample_text(5, 6), cx));
-        let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
+        let buffer_snapshot = buffer.read(cx).snapshot();
+        let mut map = FoldMap::new(buffer_snapshot.clone()).0;
 
-        let (mut writer, _, _) = map.write(vec![], cx.as_ref());
-        writer.fold(
-            vec![
-                Point::new(0, 2)..Point::new(2, 2),
-                Point::new(3, 1)..Point::new(4, 1),
-            ],
-            cx.as_ref(),
-        );
-        let (snapshot, _) = map.read(vec![], cx.as_ref());
+        let (mut writer, _, _) = map.write(buffer_snapshot.clone(), vec![]);
+        writer.fold(vec![
+            Point::new(0, 2)..Point::new(2, 2),
+            Point::new(3, 1)..Point::new(4, 1),
+        ]);
+        let (snapshot, _) = map.read(buffer_snapshot.clone(), vec![]);
         assert_eq!(snapshot.text(), "aa…cccc\nd…eeeee");
 
-        let edits = buffer.update(cx, |buffer, cx| {
+        let (buffer_snapshot, edits) = buffer.update(cx, |buffer, cx| {
             let v0 = buffer.version();
             buffer.edit(Some(Point::new(2, 2)..Point::new(3, 1)), "", cx);
-            buffer.edits_since(&v0).collect()
+            (buffer.snapshot(), buffer.edits_since(&v0).collect())
         });
-        let (snapshot, _) = map.read(edits, cx.as_ref());
+        let (snapshot, _) = map.read(buffer_snapshot.clone(), edits);
         assert_eq!(snapshot.text(), "aa…eeeee");
     }
 
     #[gpui::test]
     fn test_folds_in_range(cx: &mut gpui::MutableAppContext) {
         let buffer = cx.add_model(|cx| Buffer::new(0, sample_text(5, 6), cx));
-        let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
+        let buffer_snapshot = buffer.read(cx).snapshot();
+        let mut map = FoldMap::new(buffer_snapshot.clone()).0;
         let buffer = buffer.read(cx);
 
-        let (mut writer, _, _) = map.write(vec![], cx.as_ref());
-        writer.fold(
-            vec![
-                Point::new(0, 2)..Point::new(2, 2),
-                Point::new(0, 4)..Point::new(1, 0),
-                Point::new(1, 2)..Point::new(3, 2),
-                Point::new(3, 1)..Point::new(4, 1),
-            ],
-            cx.as_ref(),
-        );
-        let (snapshot, _) = map.read(vec![], cx.as_ref());
+        let (mut writer, _, _) = map.write(buffer_snapshot.clone(), vec![]);
+        writer.fold(vec![
+            Point::new(0, 2)..Point::new(2, 2),
+            Point::new(0, 4)..Point::new(1, 0),
+            Point::new(1, 2)..Point::new(3, 2),
+            Point::new(3, 1)..Point::new(4, 1),
+        ]);
+        let (snapshot, _) = map.read(buffer_snapshot.clone(), vec![]);
         let fold_ranges = snapshot
             .folds_in_range(Point::new(1, 0)..Point::new(1, 3))
             .map(|fold| fold.start.to_point(buffer)..fold.end.to_point(buffer))
@@ -1249,22 +1263,23 @@ mod tests {
             let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
             Buffer::new(0, text, cx)
         });
-        let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
+        let buffer_snapshot = buffer.read(cx).snapshot();
+        let mut map = FoldMap::new(buffer_snapshot.clone()).0;
 
-        let (mut initial_snapshot, _) = map.read(vec![], cx.as_ref());
+        let (mut initial_snapshot, _) = map.read(buffer_snapshot.clone(), vec![]);
         let mut snapshot_edits = Vec::new();
 
         for _ in 0..operations {
             log::info!("text: {:?}", buffer.read(cx).text());
             let buffer_edits = match rng.gen_range(0..=100) {
                 0..=59 => {
-                    snapshot_edits.extend(map.randomly_mutate(&mut rng, cx.as_ref()));
+                    snapshot_edits.extend(map.randomly_mutate(&mut rng));
                     vec![]
                 }
-                _ => buffer.update(cx, |buffer, _| {
+                _ => buffer.update(cx, |buffer, cx| {
                     let start_version = buffer.version.clone();
                     let edit_count = rng.gen_range(1..=5);
-                    buffer.randomly_edit(&mut rng, edit_count);
+                    buffer.randomly_edit(&mut rng, edit_count, cx);
                     let edits = buffer
                         .edits_since::<Point>(&start_version)
                         .collect::<Vec<_>>();
@@ -1272,14 +1287,17 @@ mod tests {
                     buffer.edits_since::<usize>(&start_version).collect()
                 }),
             };
+            let buffer_snapshot = buffer.read(cx).snapshot();
 
-            let buffer = map.buffer.read(cx).snapshot();
-            let mut expected_text: String = buffer.text().to_string();
+            let (snapshot, edits) = map.read(buffer_snapshot.clone(), buffer_edits);
+            snapshot_edits.push((snapshot.clone(), edits));
+
+            let mut expected_text: String = buffer_snapshot.text().to_string();
             let mut expected_buffer_rows = Vec::new();
-            let mut next_row = buffer.max_point().row;
-            for fold_range in map.merged_fold_ranges(cx.as_ref()).into_iter().rev() {
-                let fold_start = buffer.point_for_offset(fold_range.start).unwrap();
-                let fold_end = buffer.point_for_offset(fold_range.end).unwrap();
+            let mut next_row = buffer_snapshot.max_point().row;
+            for fold_range in map.merged_fold_ranges().into_iter().rev() {
+                let fold_start = buffer_snapshot.point_for_offset(fold_range.start).unwrap();
+                let fold_end = buffer_snapshot.point_for_offset(fold_range.end).unwrap();
                 expected_buffer_rows.extend((fold_end.row + 1..=next_row).rev());
                 next_row = fold_start.row;
 
@@ -1288,9 +1306,7 @@ mod tests {
             expected_buffer_rows.extend((0..=next_row).rev());
             expected_buffer_rows.reverse();
 
-            let (snapshot, edits) = map.read(buffer_edits, cx.as_ref());
             assert_eq!(snapshot.text(), expected_text);
-            snapshot_edits.push((snapshot.clone(), edits));
 
             for (output_row, line) in expected_text.lines().enumerate() {
                 let line_len = snapshot.line_len(output_row as u32);
@@ -1309,7 +1325,7 @@ mod tests {
             let mut char_column = 0;
             for c in expected_text.chars() {
                 let buffer_point = fold_point.to_buffer_point(&snapshot);
-                let buffer_offset = buffer_point.to_offset(&buffer);
+                let buffer_offset = buffer_point.to_offset(&buffer_snapshot);
                 assert_eq!(
                     buffer_point.to_fold_point(&snapshot, Right),
                     fold_point,
@@ -1379,26 +1395,28 @@ mod tests {
                 );
             }
 
-            for fold_range in map.merged_fold_ranges(cx.as_ref()) {
+            for fold_range in map.merged_fold_ranges() {
                 let fold_point = fold_range
                     .start
-                    .to_point(&buffer)
+                    .to_point(&buffer_snapshot)
                     .to_fold_point(&snapshot, Right);
                 assert!(snapshot.is_line_folded(fold_point.row()));
             }
 
             for _ in 0..5 {
-                let end = buffer.clip_offset(rng.gen_range(0..=buffer.len()), Right);
-                let start = buffer.clip_offset(rng.gen_range(0..=end), Left);
+                let end =
+                    buffer_snapshot.clip_offset(rng.gen_range(0..=buffer_snapshot.len()), Right);
+                let start = buffer_snapshot.clip_offset(rng.gen_range(0..=end), Left);
                 let expected_folds = map
                     .folds
-                    .items(&buffer)
+                    .items(&buffer_snapshot)
                     .into_iter()
                     .filter(|fold| {
-                        let start = buffer.anchor_before(start);
-                        let end = buffer.anchor_after(end);
-                        start.cmp(&fold.0.end, &buffer).unwrap() == Ordering::Less
-                            && end.cmp(&fold.0.start, &buffer).unwrap() == Ordering::Greater
+                        let start = buffer_snapshot.anchor_before(start);
+                        let end = buffer_snapshot.anchor_after(end);
+                        start.cmp(&fold.0.end, &buffer_snapshot).unwrap() == Ordering::Less
+                            && end.cmp(&fold.0.start, &buffer_snapshot).unwrap()
+                                == Ordering::Greater
                     })
                     .map(|fold| fold.0)
                     .collect::<Vec<_>>();
@@ -1456,26 +1474,24 @@ mod tests {
         let text = sample_text(6, 6) + "\n";
         let buffer = cx.add_model(|cx| Buffer::new(0, text, cx));
 
-        let mut map = FoldMap::new(buffer.clone(), cx.as_ref()).0;
+        let buffer_snapshot = buffer.read(cx).snapshot();
+        let mut map = FoldMap::new(buffer_snapshot.clone()).0;
 
-        let (mut writer, _, _) = map.write(vec![], cx.as_ref());
-        writer.fold(
-            vec![
-                Point::new(0, 2)..Point::new(2, 2),
-                Point::new(3, 1)..Point::new(4, 1),
-            ],
-            cx.as_ref(),
-        );
+        let (mut writer, _, _) = map.write(buffer_snapshot.clone(), vec![]);
+        writer.fold(vec![
+            Point::new(0, 2)..Point::new(2, 2),
+            Point::new(3, 1)..Point::new(4, 1),
+        ]);
 
-        let (snapshot, _) = map.read(vec![], cx.as_ref());
+        let (snapshot, _) = map.read(buffer_snapshot.clone(), vec![]);
         assert_eq!(snapshot.text(), "aa…cccc\nd…eeeee\nffffff\n");
         assert_eq!(snapshot.buffer_rows(0).collect::<Vec<_>>(), [0, 3, 5, 6]);
         assert_eq!(snapshot.buffer_rows(3).collect::<Vec<_>>(), [6]);
     }
 
     impl FoldMap {
-        fn merged_fold_ranges(&self, cx: &AppContext) -> Vec<Range<usize>> {
-            let buffer = self.buffer.read(cx).snapshot();
+        fn merged_fold_ranges(&self) -> Vec<Range<usize>> {
+            let buffer = self.buffer.lock().clone();
             let mut folds = self.folds.items(&buffer);
             // Ensure sorting doesn't change how folds get merged and displayed.
             folds.sort_by(|a, b| a.0.cmp(&b.0, &buffer).unwrap());
@@ -1503,15 +1519,11 @@ mod tests {
             merged_ranges
         }
 
-        pub fn randomly_mutate(
-            &mut self,
-            rng: &mut impl Rng,
-            cx: &AppContext,
-        ) -> Vec<(Snapshot, Vec<FoldEdit>)> {
+        pub fn randomly_mutate(&mut self, rng: &mut impl Rng) -> Vec<(Snapshot, Vec<FoldEdit>)> {
             let mut snapshot_edits = Vec::new();
             match rng.gen_range(0..=100) {
                 0..=39 if !self.folds.is_empty() => {
-                    let buffer = self.buffer.read(cx);
+                    let buffer = self.buffer.lock().clone();
                     let mut to_unfold = Vec::new();
                     for _ in 0..rng.gen_range(1..=3) {
                         let end = buffer.clip_offset(rng.gen_range(0..=buffer.len()), Right);
@@ -1519,13 +1531,13 @@ mod tests {
                         to_unfold.push(start..end);
                     }
                     log::info!("unfolding {:?}", to_unfold);
-                    let (mut writer, snapshot, edits) = self.write(vec![], cx.as_ref());
+                    let (mut writer, snapshot, edits) = self.write(buffer, vec![]);
                     snapshot_edits.push((snapshot, edits));
-                    let (snapshot, edits) = writer.fold(to_unfold, cx.as_ref());
+                    let (snapshot, edits) = writer.fold(to_unfold);
                     snapshot_edits.push((snapshot, edits));
                 }
                 _ => {
-                    let buffer = self.buffer.read(cx);
+                    let buffer = self.buffer.lock().clone();
                     let mut to_fold = Vec::new();
                     for _ in 0..rng.gen_range(1..=2) {
                         let end = buffer.clip_offset(rng.gen_range(0..=buffer.len()), Right);
@@ -1533,9 +1545,9 @@ mod tests {
                         to_fold.push(start..end);
                     }
                     log::info!("folding {:?}", to_fold);
-                    let (mut writer, snapshot, edits) = self.write(vec![], cx.as_ref());
+                    let (mut writer, snapshot, edits) = self.write(buffer, vec![]);
                     snapshot_edits.push((snapshot, edits));
-                    let (snapshot, edits) = writer.fold(to_fold, cx.as_ref());
+                    let (snapshot, edits) = writer.fold(to_fold);
                     snapshot_edits.push((snapshot, edits));
                 }
             }
diff --git a/crates/editor/src/display_map/tab_map.rs b/crates/editor/src/display_map/tab_map.rs
index 6e930fefd0..1a9163ba2b 100644
--- a/crates/editor/src/display_map/tab_map.rs
+++ b/crates/editor/src/display_map/tab_map.rs
@@ -470,11 +470,12 @@ mod tests {
             let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
             Buffer::new(0, text, cx)
         });
+        let buffer_snapshot = buffer.read(cx).snapshot();
         log::info!("Buffer text: {:?}", buffer.read(cx).text());
 
-        let (mut fold_map, _) = FoldMap::new(buffer.clone(), cx);
-        fold_map.randomly_mutate(&mut rng, cx);
-        let (folds_snapshot, _) = fold_map.read(vec![], cx);
+        let (mut fold_map, _) = FoldMap::new(buffer_snapshot.clone());
+        fold_map.randomly_mutate(&mut rng);
+        let (folds_snapshot, _) = fold_map.read(buffer_snapshot.clone(), vec![]);
         log::info!("FoldMap text: {:?}", folds_snapshot.text());
 
         let (_, tabs_snapshot) = TabMap::new(folds_snapshot.clone(), tab_size);
diff --git a/crates/editor/src/display_map/wrap_map.rs b/crates/editor/src/display_map/wrap_map.rs
index d7c453675c..6d8ddcece0 100644
--- a/crates/editor/src/display_map/wrap_map.rs
+++ b/crates/editor/src/display_map/wrap_map.rs
@@ -1026,7 +1026,8 @@ mod tests {
             let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
             Buffer::new(0, text, cx)
         });
-        let (mut fold_map, folds_snapshot) = cx.read(|cx| FoldMap::new(buffer.clone(), cx));
+        let buffer_snapshot = buffer.read_with(&cx, |buffer, _| buffer.snapshot());
+        let (mut fold_map, folds_snapshot) = FoldMap::new(buffer_snapshot.clone());
         let (tab_map, tabs_snapshot) = TabMap::new(folds_snapshot.clone(), tab_size);
         log::info!(
             "Unwrapped text (no folds): {:?}",
@@ -1079,9 +1080,7 @@ mod tests {
                     wrap_map.update(&mut cx, |map, cx| map.set_wrap_width(wrap_width, cx));
                 }
                 20..=39 => {
-                    for (folds_snapshot, fold_edits) in
-                        cx.read(|cx| fold_map.randomly_mutate(&mut rng, cx))
-                    {
+                    for (folds_snapshot, fold_edits) in fold_map.randomly_mutate(&mut rng) {
                         let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits);
                         let (mut snapshot, wrap_edits) = wrap_map
                             .update(&mut cx, |map, cx| map.sync(tabs_snapshot, tab_edits, cx));
@@ -1091,19 +1090,18 @@ mod tests {
                     }
                 }
                 _ => {
-                    buffer.update(&mut cx, |buffer, _| {
+                    buffer.update(&mut cx, |buffer, cx| {
                         let v0 = buffer.version();
-                        buffer.randomly_mutate(&mut rng);
+                        let edit_count = rng.gen_range(1..=5);
+                        buffer.randomly_edit(&mut rng, edit_count, cx);
                         buffer_edits.extend(buffer.edits_since(&v0));
                     });
                 }
             }
 
-            log::info!(
-                "Unwrapped text (no folds): {:?}",
-                buffer.read_with(&cx, |buf, _| buf.text())
-            );
-            let (folds_snapshot, fold_edits) = cx.read(|cx| fold_map.read(buffer_edits, cx));
+            let buffer_snapshot = buffer.read_with(&cx, |buffer, _| buffer.snapshot());
+            log::info!("Unwrapped text (no folds): {:?}", buffer_snapshot.text());
+            let (folds_snapshot, fold_edits) = fold_map.read(buffer_snapshot, buffer_edits);
             log::info!(
                 "Unwrapped text (unexpanded tabs): {:?}",
                 folds_snapshot.text()
diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 037b9f8a12..1c45bf15a7 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -72,8 +72,10 @@ pub struct Snapshot {
     text: text::Snapshot,
     tree: Option<Tree>,
     diagnostics: AnchorRangeMultimap<Diagnostic>,
+    diagnostics_update_count: usize,
     is_parsing: bool,
     language: Option<Arc<Language>>,
+    parse_count: usize,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -339,8 +341,10 @@ impl Buffer {
             text: self.text.snapshot(),
             tree: self.syntax_tree(),
             diagnostics: self.diagnostics.clone(),
+            diagnostics_update_count: self.diagnostics_update_count,
             is_parsing: self.parsing_in_background,
             language: self.language.clone(),
+            parse_count: self.parse_count,
         }
     }
 
@@ -1465,18 +1469,26 @@ impl Buffer {
 
 #[cfg(any(test, feature = "test-support"))]
 impl Buffer {
-    pub fn randomly_edit<T>(&mut self, rng: &mut T, old_range_count: usize)
-    where
+    pub fn randomly_edit<T>(
+        &mut self,
+        rng: &mut T,
+        old_range_count: usize,
+        cx: &mut ModelContext<Self>,
+    ) where
         T: rand::Rng,
     {
+        self.start_transaction(None).unwrap();
         self.text.randomly_edit(rng, old_range_count);
+        self.end_transaction(None, cx).unwrap();
     }
 
-    pub fn randomly_mutate<T>(&mut self, rng: &mut T)
+    pub fn randomly_mutate<T>(&mut self, rng: &mut T, cx: &mut ModelContext<Self>)
     where
         T: rand::Rng,
     {
+        self.start_transaction(None).unwrap();
         self.text.randomly_mutate(rng);
+        self.end_transaction(None, cx).unwrap();
     }
 }
 
@@ -1703,6 +1715,14 @@ impl Snapshot {
             .as_ref()
             .and_then(|language| language.grammar.as_ref())
     }
+
+    pub fn diagnostics_update_count(&self) -> usize {
+        self.diagnostics_update_count
+    }
+
+    pub fn parse_count(&self) -> usize {
+        self.parse_count
+    }
 }
 
 impl Clone for Snapshot {
@@ -1711,8 +1731,10 @@ impl Clone for Snapshot {
             text: self.text.clone(),
             tree: self.tree.clone(),
             diagnostics: self.diagnostics.clone(),
+            diagnostics_update_count: self.diagnostics_update_count,
             is_parsing: self.is_parsing,
             language: self.language.clone(),
+            parse_count: self.parse_count,
         }
     }
 }