Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

230 KB
Raw Blame
use super::{
    Highlights,
    fold_map::Chunk,
    wrap_map::{self, WrapEdit, WrapPatch, WrapPoint, WrapSnapshot},
};
use crate::{
    EditorStyle, GutterDimensions,
    display_map::{Companion, dimensions::RowDelta, wrap_map::WrapRow},
};
use collections::{Bound, HashMap, HashSet};
use gpui::{AnyElement, App, EntityId, Pixels, Window};
use language::{LanguageAwareStyling, Patch, Point};
use multi_buffer::{
    Anchor, ExcerptBoundaryInfo, MultiBuffer, MultiBufferOffset, MultiBufferPoint, MultiBufferRow,
    MultiBufferSnapshot, RowInfo, ToOffset, ToPoint as _,
};
use parking_lot::Mutex;
use std::{
    cell::{Cell, RefCell},
    cmp::{self, Ordering},
    fmt::Debug,
    ops::{Deref, DerefMut, Not, Range, RangeBounds, RangeInclusive},
    sync::{
        Arc,
        atomic::{AtomicUsize, Ordering::SeqCst},
    },
};
use sum_tree::{Bias, ContextLessSummary, Dimensions, SumTree, TreeMap};
use text::{BufferId, Edit};
use ui::{ElementId, IntoElement};

const NEWLINES: &[u8; rope::Chunk::MASK_BITS] = &[b'\n'; _];
const BULLETS: &[u8; rope::Chunk::MASK_BITS] = &[b'*'; _];

/// Tracks custom blocks such as diagnostics that should be displayed within buffer.
///
/// See the [`display_map` module documentation](crate::display_map) for more information.
pub struct BlockMap {
    pub(super) wrap_snapshot: RefCell<WrapSnapshot>,
    next_block_id: AtomicUsize,
    custom_blocks: Vec<Arc<CustomBlock>>,
    custom_blocks_by_id: TreeMap<CustomBlockId, Arc<CustomBlock>>,
    transforms: RefCell<SumTree<Transform>>,
    buffer_header_height: u32,
    excerpt_header_height: u32,
    pub(super) folded_buffers: HashSet<BufferId>,
    buffers_with_disabled_headers: HashSet<BufferId>,
    pub(super) deferred_edits: Cell<Patch<WrapRow>>,
}

pub struct BlockMapReader<'a> {
    pub blocks: &'a Vec<Arc<CustomBlock>>,
    pub snapshot: BlockSnapshot,
}

pub struct BlockMapWriter<'a> {
    block_map: &'a mut BlockMap,
    companion: Option<BlockMapWriterCompanion<'a>>,
}

/// Auxiliary data needed when modifying a BlockMap whose parent DisplayMap has a companion.
struct BlockMapWriterCompanion<'a> {
    display_map_id: EntityId,
    companion_wrap_snapshot: WrapSnapshot,
    companion: &'a Companion,
    inverse: Option<BlockMapInverseWriter<'a>>,
}

struct BlockMapInverseWriter<'a> {
    companion_multibuffer: &'a MultiBuffer,
    companion_writer: Box<BlockMapWriter<'a>>,
}

#[derive(Clone)]
pub struct BlockSnapshot {
    pub(super) wrap_snapshot: WrapSnapshot,
    transforms: SumTree<Transform>,
    custom_blocks_by_id: TreeMap<CustomBlockId, Arc<CustomBlock>>,
    pub(super) buffer_header_height: u32,
    pub(super) excerpt_header_height: u32,
    pub(super) buffers_with_disabled_headers: HashSet<BufferId>,
}

impl Deref for BlockSnapshot {
    type Target = WrapSnapshot;

    fn deref(&self) -> &Self::Target {
        &self.wrap_snapshot
    }
}

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct CustomBlockId(pub usize);

impl From<CustomBlockId> for ElementId {
    fn from(val: CustomBlockId) -> Self {
        val.0.into()
    }
}

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct SpacerId(pub usize);

/// A zero-indexed point in a text buffer consisting of a row and column
/// adjusted for inserted blocks, wrapped rows, tabs, folds and inlays.
#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
pub struct BlockPoint(pub Point);

#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
pub struct BlockRow(pub u32);

impl_for_row_types! {
    BlockRow => RowDelta
}

impl BlockPoint {
    pub fn row(&self) -> BlockRow {
        BlockRow(self.0.row)
    }
}

/// Forward-only cursor mapping [`WrapPoint`]s to [`BlockPoint`]s, reusing its
/// tree position across calls. This is the streaming equivalent of
/// [`BlockSnapshot::to_block_point`]; callers must provide non-decreasing wrap
/// points.
pub struct BlockPointCursor<'a> {
    snapshot: &'a BlockSnapshot,
    cursor: sum_tree::Cursor<'a, 'static, Transform, Dimensions<WrapRow, BlockRow>>,
}

impl BlockPointCursor<'_> {
    /// Resets the cursor to the start so it can seek backward again.
    pub fn reset(&mut self) {
        self.cursor.reset();
    }

    pub fn map(&mut self, wrap_point: WrapPoint) -> BlockPoint {
        let cursor = &mut self.cursor;
        if cursor.did_seek() {
            cursor.seek_forward(&wrap_point.row(), Bias::Right);
        } else {
            cursor.seek(&wrap_point.row(), Bias::Right);
        }
        if let Some(transform) = cursor.item() {
            if transform.block.is_some() {
                BlockPoint::new(cursor.start().1, 0)
            } else {
                let input_start = Point::new(cursor.start().0.0, 0);
                let output_start = Point::new(cursor.start().1.0, 0);
                let input_overshoot = wrap_point.0 - input_start;
                BlockPoint(output_start + input_overshoot)
            }
        } else {
            self.snapshot.max_point()
        }
    }
}

pub type RenderBlock = Arc<dyn Send + Sync + Fn(&mut BlockContext) -> AnyElement>;

/// Where to place a block.
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum BlockPlacement<T> {
    /// Place the block above the given position.
    Above(T),
    /// Place the block below the given position.
    Below(T),
    /// Place the block next the given position.
    Near(T),
    /// Replace the given range of positions with the block.
    Replace(RangeInclusive<T>),
}

impl<T> BlockPlacement<T> {
    pub fn start(&self) -> &T {
        match self {
            BlockPlacement::Above(position) => position,
            BlockPlacement::Below(position) => position,
            BlockPlacement::Near(position) => position,
            BlockPlacement::Replace(range) => range.start(),
        }
    }

    fn end(&self) -> &T {
        match self {
            BlockPlacement::Above(position) => position,
            BlockPlacement::Below(position) => position,
            BlockPlacement::Near(position) => position,
            BlockPlacement::Replace(range) => range.end(),
        }
    }

    pub fn as_ref(&self) -> BlockPlacement<&T> {
        match self {
            BlockPlacement::Above(position) => BlockPlacement::Above(position),
            BlockPlacement::Below(position) => BlockPlacement::Below(position),
            BlockPlacement::Near(position) => BlockPlacement::Near(position),
            BlockPlacement::Replace(range) => BlockPlacement::Replace(range.start()..=range.end()),
        }
    }

    pub fn map<R>(self, mut f: impl FnMut(T) -> R) -> BlockPlacement<R> {
        match self {
            BlockPlacement::Above(position) => BlockPlacement::Above(f(position)),
            BlockPlacement::Below(position) => BlockPlacement::Below(f(position)),
            BlockPlacement::Near(position) => BlockPlacement::Near(f(position)),
            BlockPlacement::Replace(range) => {
                let (start, end) = range.into_inner();
                BlockPlacement::Replace(f(start)..=f(end))
            }
        }
    }

    fn tie_break(&self) -> u8 {
        match self {
            BlockPlacement::Replace(_) => 0,
            BlockPlacement::Above(_) => 1,
            BlockPlacement::Near(_) => 2,
            BlockPlacement::Below(_) => 3,
        }
    }
}

impl BlockPlacement<Anchor> {
    #[ztracing::instrument(skip_all)]
    fn cmp(&self, other: &Self, buffer: &MultiBufferSnapshot) -> Ordering {
        self.start()
            .cmp(other.start(), buffer)
            .then_with(|| other.end().cmp(self.end(), buffer))
            .then_with(|| self.tie_break().cmp(&other.tie_break()))
    }

    #[ztracing::instrument(skip_all)]
    fn to_wrap_row(&self, wrap_snapshot: &WrapSnapshot) -> Option<BlockPlacement<WrapRow>> {
        let buffer_snapshot = wrap_snapshot.buffer_snapshot();
        match self {
            BlockPlacement::Above(position) => {
                let mut position = position.to_point(buffer_snapshot);
                position.column = 0;
                let wrap_row = wrap_snapshot.make_wrap_point(position, Bias::Left).row();
                Some(BlockPlacement::Above(wrap_row))
            }
            BlockPlacement::Near(position) => {
                let mut position = position.to_point(buffer_snapshot);
                position.column = buffer_snapshot.line_len(MultiBufferRow(position.row));
                let wrap_row = wrap_snapshot.make_wrap_point(position, Bias::Left).row();
                Some(BlockPlacement::Near(wrap_row))
            }
            BlockPlacement::Below(position) => {
                let mut position = position.to_point(buffer_snapshot);
                position.column = buffer_snapshot.line_len(MultiBufferRow(position.row));
                let wrap_row = wrap_snapshot.make_wrap_point(position, Bias::Left).row();
                Some(BlockPlacement::Below(wrap_row))
            }
            BlockPlacement::Replace(range) => {
                let mut start = range.start().to_point(buffer_snapshot);
                let mut end = range.end().to_point(buffer_snapshot);
                if start == end {
                    None
                } else {
                    start.column = 0;
                    let start_wrap_row = wrap_snapshot.make_wrap_point(start, Bias::Left).row();
                    end.column = buffer_snapshot.line_len(MultiBufferRow(end.row));
                    let end_wrap_row = wrap_snapshot.make_wrap_point(end, Bias::Left).row();
                    Some(BlockPlacement::Replace(start_wrap_row..=end_wrap_row))
                }
            }
        }
    }
}

pub struct CustomBlock {
    pub id: CustomBlockId,
    pub placement: BlockPlacement<Anchor>,
    pub height: Option<u32>,
    style: BlockStyle,
    render: Arc<Mutex<RenderBlock>>,
    priority: usize,
}

#[derive(Clone)]
pub struct BlockProperties<P> {
    pub placement: BlockPlacement<P>,
    // None if the block takes up no space
    // (e.g. a horizontal line)
    pub height: Option<u32>,
    pub style: BlockStyle,
    pub render: RenderBlock,
    pub priority: usize,
}

impl<P: Debug> Debug for BlockProperties<P> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("BlockProperties")
            .field("placement", &self.placement)
            .field("height", &self.height)
            .field("style", &self.style)
            .finish()
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
pub enum BlockStyle {
    Fixed,
    Flex,
    /// Like `Flex` but doesn't use the gutter:
    /// - block content scrolls with buffer content
    /// - doesn't paint in gutter
    Spacer,
    Sticky,
}

#[derive(Debug, Default, Copy, Clone)]
pub struct EditorMargins {
    pub gutter: GutterDimensions,
    pub right: Pixels,
    pub extended_right: Pixels,
}

#[derive(gpui::AppContext, gpui::VisualContext)]
pub struct BlockContext<'a, 'b> {
    #[window]
    pub window: &'a mut Window,
    #[app]
    pub app: &'b mut App,
    pub anchor_x: Pixels,
    pub max_width: Pixels,
    pub margins: &'b EditorMargins,
    pub em_width: Pixels,
    pub line_height: Pixels,
    pub block_id: BlockId,
    pub height: u32,
    pub selected: bool,
    pub editor_style: &'b EditorStyle,
    pub indent_guide_padding: Pixels,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum BlockId {
    ExcerptBoundary(Anchor),
    FoldedBuffer(BufferId),
    Custom(CustomBlockId),
    Spacer(SpacerId),
}

impl From<BlockId> for ElementId {
    fn from(value: BlockId) -> Self {
        match value {
            BlockId::Custom(CustomBlockId(id)) => ("Block", id).into(),
            BlockId::ExcerptBoundary(anchor) => anchor.opaque_id().unwrap().into(),
            BlockId::FoldedBuffer(id) => ("FoldedBuffer", EntityId::from(id.to_proto())).into(),
            BlockId::Spacer(SpacerId(id)) => ("Spacer", id).into(),
        }
    }
}

impl std::fmt::Display for BlockId {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Custom(id) => write!(f, "Block({id:?})"),
            Self::ExcerptBoundary(id) => write!(f, "ExcerptBoundary({id:?})"),
            Self::FoldedBuffer(id) => write!(f, "FoldedBuffer({id:?})"),
            Self::Spacer(id) => write!(f, "Spacer({id:?})"),
        }
    }
}

#[derive(Clone, Debug)]
struct Transform {
    summary: TransformSummary,
    /// When `block` is `None`, the transform is isomorphic and passes input
    /// wrap rows through as normal text.
    block: Option<Block>,
}

#[derive(Clone)]
pub enum Block {
    Custom(Arc<CustomBlock>),
    FoldedBuffer {
        first_excerpt: ExcerptBoundaryInfo,
        height: u32,
    },
    ExcerptBoundary {
        excerpt: ExcerptBoundaryInfo,
        height: u32,
    },
    BufferHeader {
        excerpt: ExcerptBoundaryInfo,
        height: u32,
    },
    Spacer {
        id: SpacerId,
        height: u32,
        is_below: bool,
    },
}

impl Block {
    pub fn id(&self) -> BlockId {
        match self {
            Block::Custom(block) => BlockId::Custom(block.id),
            Block::ExcerptBoundary {
                excerpt: next_excerpt,
                ..
            } => BlockId::ExcerptBoundary(next_excerpt.start_anchor),
            Block::FoldedBuffer { first_excerpt, .. } => {
                BlockId::FoldedBuffer(first_excerpt.buffer_id())
            }
            Block::BufferHeader {
                excerpt: next_excerpt,
                ..
            } => BlockId::ExcerptBoundary(next_excerpt.start_anchor),
            Block::Spacer { id, .. } => BlockId::Spacer(*id),
        }
    }

    pub fn has_height(&self) -> bool {
        match self {
            Block::Custom(block) => block.height.is_some(),
            Block::ExcerptBoundary { .. }
            | Block::FoldedBuffer { .. }
            | Block::BufferHeader { .. }
            | Block::Spacer { .. } => true,
        }
    }

    pub fn height(&self) -> u32 {
        match self {
            Block::Custom(block) => block.height.unwrap_or(0),
            Block::ExcerptBoundary { height, .. }
            | Block::FoldedBuffer { height, .. }
            | Block::BufferHeader { height, .. }
            | Block::Spacer { height, .. } => *height,
        }
    }

    pub fn style(&self) -> BlockStyle {
        match self {
            Block::Custom(block) => block.style,
            Block::ExcerptBoundary { .. }
            | Block::FoldedBuffer { .. }
            | Block::BufferHeader { .. } => BlockStyle::Sticky,
            Block::Spacer { .. } => BlockStyle::Spacer,
        }
    }

    fn place_above(&self) -> bool {
        match self {
            Block::Custom(block) => matches!(block.placement, BlockPlacement::Above(_)),
            Block::FoldedBuffer { .. } => false,
            Block::ExcerptBoundary { .. } => true,
            Block::BufferHeader { .. } => true,
            Block::Spacer { is_below, .. } => !*is_below,
        }
    }

    pub fn place_near(&self) -> bool {
        match self {
            Block::Custom(block) => matches!(block.placement, BlockPlacement::Near(_)),
            Block::FoldedBuffer { .. } => false,
            Block::ExcerptBoundary { .. } => false,
            Block::BufferHeader { .. } => false,
            Block::Spacer { .. } => false,
        }
    }

    fn place_below(&self) -> bool {
        match self {
            Block::Custom(block) => matches!(
                block.placement,
                BlockPlacement::Below(_) | BlockPlacement::Near(_)
            ),
            Block::FoldedBuffer { .. } => false,
            Block::ExcerptBoundary { .. } => false,
            Block::BufferHeader { .. } => false,
            Block::Spacer { is_below, .. } => *is_below,
        }
    }

    fn is_replacement(&self) -> bool {
        match self {
            Block::Custom(block) => matches!(block.placement, BlockPlacement::Replace(_)),
            Block::FoldedBuffer { .. } => true,
            Block::ExcerptBoundary { .. } => false,
            Block::BufferHeader { .. } => false,
            Block::Spacer { .. } => false,
        }
    }

    pub(crate) fn is_header(&self) -> bool {
        match self {
            Block::Custom(_) => false,
            Block::FoldedBuffer { .. } => true,
            Block::ExcerptBoundary { .. } => true,
            Block::BufferHeader { .. } => true,
            Block::Spacer { .. } => false,
        }
    }

    pub fn is_buffer_header(&self) -> bool {
        match self {
            Block::Custom(_) => false,
            Block::FoldedBuffer { .. } => true,
            Block::ExcerptBoundary { .. } => false,
            Block::BufferHeader { .. } => true,
            Block::Spacer { .. } => false,
        }
    }
}

impl Debug for Block {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Custom(block) => f.debug_struct("Custom").field("block", block).finish(),
            Self::FoldedBuffer {
                first_excerpt,
                height,
            } => f
                .debug_struct("FoldedBuffer")
                .field("first_excerpt", &first_excerpt)
                .field("height", height)
                .finish(),
            Self::ExcerptBoundary { excerpt, height } => f
                .debug_struct("ExcerptBoundary")
                .field("excerpt", excerpt)
                .field("height", height)
                .finish(),
            Self::BufferHeader { excerpt, height } => f
                .debug_struct("BufferHeader")
                .field("excerpt", excerpt)
                .field("height", height)
                .finish(),
            Self::Spacer {
                id,
                height,
                is_below: _,
            } => f
                .debug_struct("Spacer")
                .field("id", id)
                .field("height", height)
                .finish(),
        }
    }
}

#[derive(Clone, Debug, Default)]
struct TransformSummary {
    input_rows: WrapRow,
    output_rows: BlockRow,
    longest_row: BlockRow,
    longest_row_chars: u32,
    has_replacement_blocks: bool,
}

pub struct BlockChunks<'a> {
    transforms: sum_tree::Cursor<'a, 'static, Transform, Dimensions<BlockRow, WrapRow>>,
    input_chunks: wrap_map::WrapChunks<'a>,
    input_chunk: Chunk<'a>,
    output_row: BlockRow,
    max_output_row: BlockRow,
    line_count_overflow: RowDelta,
    masked: bool,
}

#[derive(Clone)]
pub struct BlockRows<'a> {
    transforms: sum_tree::Cursor<'a, 'static, Transform, Dimensions<BlockRow, WrapRow>>,
    input_rows: wrap_map::WrapRows<'a>,
    output_row: BlockRow,
    started: bool,
}

#[derive(Clone, Copy)]
pub struct CompanionView<'a> {
    display_map_id: EntityId,
    companion_wrap_snapshot: &'a WrapSnapshot,
    companion_wrap_edits: &'a WrapPatch,
    companion: &'a Companion,
}

impl<'a> CompanionView<'a> {
    pub(crate) fn new(
        display_map_id: EntityId,
        companion_wrap_snapshot: &'a WrapSnapshot,
        companion_wrap_edits: &'a WrapPatch,
        companion: &'a Companion,
    ) -> Self {
        Self {
            display_map_id,
            companion_wrap_snapshot,
            companion_wrap_edits,
            companion,
        }
    }
}

impl<'a> From<CompanionViewMut<'a>> for CompanionView<'a> {
    fn from(view_mut: CompanionViewMut<'a>) -> Self {
        Self {
            display_map_id: view_mut.display_map_id,
            companion_wrap_snapshot: view_mut.companion_wrap_snapshot,
            companion_wrap_edits: view_mut.companion_wrap_edits,
            companion: view_mut.companion,
        }
    }
}

impl<'a> From<&'a CompanionViewMut<'a>> for CompanionView<'a> {
    fn from(view_mut: &'a CompanionViewMut<'a>) -> Self {
        Self {
            display_map_id: view_mut.display_map_id,
            companion_wrap_snapshot: view_mut.companion_wrap_snapshot,
            companion_wrap_edits: view_mut.companion_wrap_edits,
            companion: view_mut.companion,
        }
    }
}

pub struct CompanionViewMut<'a> {
    display_map_id: EntityId,
    companion_display_map_id: EntityId,
    companion_wrap_snapshot: &'a WrapSnapshot,
    companion_wrap_edits: &'a WrapPatch,
    companion_multibuffer: &'a MultiBuffer,
    companion_block_map: &'a mut BlockMap,
    companion: &'a Companion,
}

impl<'a> CompanionViewMut<'a> {
    pub(crate) fn new(
        display_map_id: EntityId,
        companion_display_map_id: EntityId,
        companion_wrap_snapshot: &'a WrapSnapshot,
        companion_wrap_edits: &'a WrapPatch,
        companion_multibuffer: &'a MultiBuffer,
        companion: &'a Companion,
        companion_block_map: &'a mut BlockMap,
    ) -> Self {
        Self {
            display_map_id,
            companion_display_map_id,
            companion_wrap_snapshot,
            companion_wrap_edits,
            companion_multibuffer,
            companion,
            companion_block_map,
        }
    }
}

impl BlockMap {
    #[ztracing::instrument(skip_all)]
    pub fn new(
        wrap_snapshot: WrapSnapshot,
        buffer_header_height: u32,
        excerpt_header_height: u32,
    ) -> Self {
        let row_count = wrap_snapshot.max_point().row() + WrapRow(1);
        let mut transforms = SumTree::default();
        push_isomorphic(&mut transforms, row_count - WrapRow(0), &wrap_snapshot);
        let map = Self {
            next_block_id: AtomicUsize::new(0),
            custom_blocks: Vec::new(),
            custom_blocks_by_id: TreeMap::default(),
            folded_buffers: HashSet::default(),
            buffers_with_disabled_headers: HashSet::default(),
            transforms: RefCell::new(transforms),
            wrap_snapshot: RefCell::new(wrap_snapshot.clone()),
            buffer_header_height,
            excerpt_header_height,
            deferred_edits: Cell::default(),
        };
        map.sync(
            &wrap_snapshot,
            Patch::new(vec![Edit {
                old: WrapRow(0)..row_count,
                new: WrapRow(0)..row_count,
            }]),
            None,
        );
        map
    }

    #[ztracing::instrument(skip_all)]
    pub(crate) fn read(
        &self,
        wrap_snapshot: WrapSnapshot,
        edits: WrapPatch,
        companion_view: Option<CompanionView>,
    ) -> BlockMapReader<'_> {
        self.sync(&wrap_snapshot, edits, companion_view);
        *self.wrap_snapshot.borrow_mut() = wrap_snapshot.clone();
        BlockMapReader {
            blocks: &self.custom_blocks,
            snapshot: BlockSnapshot {
                wrap_snapshot,
                transforms: self.transforms.borrow().clone(),
                custom_blocks_by_id: self.custom_blocks_by_id.clone(),
                buffer_header_height: self.buffer_header_height,
                excerpt_header_height: self.excerpt_header_height,
                buffers_with_disabled_headers: self.buffers_with_disabled_headers.clone(),
            },
        }
    }

    #[ztracing::instrument(skip_all)]
    pub(crate) fn write<'a>(
        &'a mut self,
        wrap_snapshot: WrapSnapshot,
        edits: WrapPatch,
        companion_view: Option<CompanionViewMut<'a>>,
    ) -> BlockMapWriter<'a> {
        self.sync(
            &wrap_snapshot,
            edits.clone(),
            companion_view.as_ref().map(CompanionView::from),
        );
        *self.wrap_snapshot.borrow_mut() = wrap_snapshot.clone();
        let companion = if let Some(companion_view) = companion_view {
            companion_view.companion_block_map.sync(
                companion_view.companion_wrap_snapshot,
                companion_view.companion_wrap_edits.clone(),
                Some(CompanionView::new(
                    companion_view.companion_display_map_id,
                    &wrap_snapshot,
                    &edits,
                    companion_view.companion,
                )),
            );
            *companion_view
                .companion_block_map
                .wrap_snapshot
                .borrow_mut() = companion_view.companion_wrap_snapshot.clone();
            Some(BlockMapWriterCompanion {
                display_map_id: companion_view.display_map_id,
                companion_wrap_snapshot: companion_view.companion_wrap_snapshot.clone(),
                companion: companion_view.companion,
                inverse: Some(BlockMapInverseWriter {
                    companion_multibuffer: companion_view.companion_multibuffer,
                    companion_writer: Box::new(BlockMapWriter {
                        block_map: companion_view.companion_block_map,
                        companion: Some(BlockMapWriterCompanion {
                            display_map_id: companion_view.companion_display_map_id,
                            companion_wrap_snapshot: wrap_snapshot,
                            companion: companion_view.companion,
                            inverse: None,
                        }),
                    }),
                }),
            })
        } else {
            None
        };
        BlockMapWriter {
            block_map: self,
            companion,
        }
    }

    // Warning: doesn't sync the block map, use advisedly
    pub(crate) fn insert_block_raw(
        &mut self,
        block: BlockProperties<Anchor>,
        buffer: &MultiBufferSnapshot,
    ) -> CustomBlockId {
        let id = CustomBlockId(self.next_block_id.fetch_add(1, SeqCst));
        let block_ix = match self
            .custom_blocks
            .binary_search_by(|probe| probe.placement.cmp(&block.placement, &buffer))
        {
            Ok(ix) | Err(ix) => ix,
        };
        let new_block = Arc::new(CustomBlock {
            id,
            placement: block.placement.clone(),
            height: block.height,
            style: block.style,
            render: Arc::new(Mutex::new(block.render.clone())),
            priority: block.priority,
        });
        self.custom_blocks.insert(block_ix, new_block.clone());
        self.custom_blocks_by_id.insert(id, new_block);
        id
    }

    // Warning: doesn't sync the block map, use advisedly
    pub(crate) fn retain_blocks_raw(&mut self, pred: &mut dyn FnMut(&Arc<CustomBlock>) -> bool) {
        let mut ids_to_remove = HashSet::default();
        self.custom_blocks.retain(|block| {
            let keep = pred(block);
            if !keep {
                ids_to_remove.insert(block.id);
            }
            keep
        });
        self.custom_blocks_by_id
            .retain(|id, _| !ids_to_remove.contains(id));
    }

    // Warning: doesn't sync the block map, use advisedly
    pub(crate) fn blocks_raw(&self) -> impl Iterator<Item = &Arc<CustomBlock>> {
        self.custom_blocks.iter()
    }

    #[ztracing::instrument(skip_all, fields(edits = ?edits))]
    fn sync(
        &self,
        wrap_snapshot: &WrapSnapshot,
        mut edits: WrapPatch,
        companion_view: Option<CompanionView>,
    ) {
        let buffer = wrap_snapshot.buffer_snapshot();

        edits = self.deferred_edits.take().compose(edits);

        let max_point = wrap_snapshot.max_point();

        // Handle changing the last excerpt if it is empty.
        if buffer.trailing_excerpt_update_count()
            != self
                .wrap_snapshot
                .borrow()
                .buffer_snapshot()
                .trailing_excerpt_update_count()
        {
            let edit_start = wrap_snapshot.prev_row_boundary(max_point);
            let edit_end = max_point.row() + WrapRow(1); // this is end of file
            edits = edits.compose([WrapEdit {
                old: edit_start..edit_end,
                new: edit_start..edit_end,
            }]);
        }

        // Pull in companion edits to ensure we recompute spacers in ranges that have changed in the companion.
        if let Some(CompanionView {
            companion_wrap_snapshot: companion_new_snapshot,
            companion_wrap_edits: companion_edits,
            companion,
            display_map_id,
            ..
        }) = companion_view
        {
            let mut companion_edits_in_my_space: Vec<WrapEdit> = companion_edits
                .clone()
                .into_inner()
                .iter()
                .map(|edit| {
                    let companion_start = companion_new_snapshot
                        .to_point(WrapPoint::new(edit.new.start, 0), Bias::Left);
                    let companion_end = companion_new_snapshot
                        .to_point(WrapPoint::new(edit.new.end, 0), Bias::Left);

                    let my_start = companion
                        .convert_point_from_companion(
                            display_map_id,
                            wrap_snapshot.buffer_snapshot(),
                            companion_new_snapshot.buffer_snapshot(),
                            companion_start,
                        )
                        .start;
                    let my_end = companion
                        .convert_point_from_companion(
                            display_map_id,
                            wrap_snapshot.buffer_snapshot(),
                            companion_new_snapshot.buffer_snapshot(),
                            companion_end,
                        )
                        .end;

                    let mut my_start = wrap_snapshot.make_wrap_point(my_start, Bias::Left);
                    let mut my_end = wrap_snapshot.make_wrap_point(my_end, Bias::Left);
                    // TODO(split-diff) should use trailing_excerpt_update_count for the second case
                    if my_end.column() > 0 || my_end == max_point {
                        *my_end.row_mut() += 1;
                        *my_end.column_mut() = 0;
                    }

                    // Empty edits won't survive Patch::compose, but we still need to make sure
                    // we recompute spacers when we get them.
                    if my_start.row() == my_end.row() {
                        if my_end.row() <= max_point.row() {
                            *my_end.row_mut() += 1;
                            *my_end.column_mut() = 0;
                        } else if my_start.row() > WrapRow(0) {
                            *my_start.row_mut() += 1;
                            *my_start.column_mut() = 0;
                        }
                    }

                    WrapEdit {
                        old: my_start.row()..my_end.row(),
                        new: my_start.row()..my_end.row(),
                    }
                })
                .collect();

            companion_edits_in_my_space.sort_by_key(|edit| edit.old.start);
            let mut merged_edits: Vec<WrapEdit> = Vec::new();
            for edit in companion_edits_in_my_space {
                if let Some(last) = merged_edits.last_mut() {
                    if edit.old.start <= last.old.end {
                        last.old.end = last.old.end.max(edit.old.end);
                        last.new.end = last.new.end.max(edit.new.end);
                        continue;
                    }
                }
                merged_edits.push(edit);
            }

            edits = edits.compose(merged_edits);
        }

        let edits = edits.into_inner();
        if edits.is_empty() {
            return;
        }

        let mut transforms = self.transforms.borrow_mut();
        let mut new_transforms = SumTree::default();
        let mut cursor = transforms.cursor::<WrapRow>(());
        let mut last_block_ix = 0;
        let mut blocks_in_edit = Vec::new();
        let mut edits = edits.into_iter().peekable();

        let mut inlay_point_cursor = wrap_snapshot.inlay_point_cursor();
        let mut tab_point_cursor = wrap_snapshot.tab_point_cursor();
        let mut fold_point_cursor = wrap_snapshot.fold_point_cursor();
        let mut wrap_point_cursor = wrap_snapshot.wrap_point_cursor();

        while let Some(edit) = edits.next() {
            let span = ztracing::debug_span!("while edits", edit = ?edit);
            let _enter = span.enter();

            let mut old_start = edit.old.start;
            let mut new_start = edit.new.start;

            // Only preserve transforms that:
            // * Strictly precedes this edit
            // * Isomorphic transforms that end *at* the start of the edit
            // * Below blocks that end at the start of the edit
            // However, if we hit a replace block that ends at the start of the edit we want to reconstruct it.
            new_transforms.append(cursor.slice(&old_start, Bias::Left), ());
            if let Some(transform) = cursor.item()
                && transform.summary.input_rows > WrapRow(0)
                && cursor.end() == old_start
                && transform.block.as_ref().is_none_or(|b| !b.is_replacement())
            {
                // Preserve the transform (push and next)
                new_transforms.push(transform.clone(), ());
                cursor.next();

                // Preserve below blocks at start of edit
                while let Some(transform) = cursor.item() {
                    if transform.block.as_ref().is_some_and(|b| b.place_below()) {
                        new_transforms.push(transform.clone(), ());
                        cursor.next();
                    } else {
                        break;
                    }
                }
            }

            // Ensure the edit starts at a transform boundary.
            // If the edit starts within an isomorphic transform, preserve its prefix
            // If the edit lands within a replacement block, expand the edit to include the start of the replaced input range
            // The cursor can sit past the end of the tree when a companion edit
            // is anchored at the new end-of-file and maps to `old_start` at the
            // very end of the old transforms; in that case there is no transform
            // preceding the edit and nothing to preserve.
            let transform_rows_before_edit = old_start - *cursor.start();
            if transform_rows_before_edit > RowDelta(0)
                && let Some(transform) = cursor.item()
            {
                if transform.block.is_none() {
                    // Preserve any portion of the old isomorphic transform that precedes this edit.
                    push_isomorphic(
                        &mut new_transforms,
                        transform_rows_before_edit,
                        wrap_snapshot,
                    );
                } else {
                    // We landed within a block that replaces some lines, so we
                    // extend the edit to start at the beginning of the
                    // replacement.
                    debug_assert!(transform.summary.input_rows > WrapRow(0));
                    old_start -= transform_rows_before_edit;
                    new_start -= transform_rows_before_edit;
                }
            }

            // Decide where the edit ends
            // * It should end at a transform boundary
            // * Coalesce edits that intersect the same transform
            let mut old_end = edit.old.end;
            let mut new_end = edit.new.end;
            loop {
                let span = ztracing::debug_span!("decide where edit ends loop");
                let _enter = span.enter();
                // Seek to the transform starting at or after the end of the edit
                cursor.seek(&old_end, Bias::Left);
                cursor.next();

                // Extend edit to the end of the discarded transform so it is reconstructed in full
                let transform_rows_after_edit = *cursor.start() - old_end;
                old_end += transform_rows_after_edit;
                new_end += transform_rows_after_edit;

                // Combine this edit with any subsequent edits that intersect the same transform.
                while let Some(next_edit) = edits.peek() {
                    if next_edit.old.start <= *cursor.start() {
                        old_end = next_edit.old.end;
                        new_end = next_edit.new.end;
                        cursor.seek(&old_end, Bias::Left);
                        cursor.next();
                        edits.next();
                    } else {
                        break;
                    }
                }

                if *cursor.start() == old_end {
                    break;
                }
            }

            // Discard below blocks at the end of the edit. They'll be reconstructed.
            while let Some(transform) = cursor.item() {
                if transform
                    .block
                    .as_ref()
                    .is_some_and(|b| b.place_below() || matches!(b, Block::Spacer { .. }))
                {
                    cursor.next();
                } else {
                    break;
                }
            }

            // Find the blocks within this edited region.
            let new_buffer_start = wrap_snapshot.to_point(WrapPoint::new(new_start, 0), Bias::Left);
            let start_bound = Bound::Included(new_buffer_start);
            let start_block_ix =
                match self.custom_blocks[last_block_ix..].binary_search_by(|probe| {
                    probe
                        .start()
                        .to_point(buffer)
                        .cmp(&new_buffer_start)
                        // Move left until we find the index of the first block starting within this edit
                        .then(Ordering::Greater)
                }) {
                    Ok(ix) | Err(ix) => last_block_ix + ix,
                };

            let end_bound;
            let end_block_ix = if new_end > max_point.row() {
                end_bound = Bound::Unbounded;
                self.custom_blocks.len()
            } else {
                let new_buffer_end = wrap_snapshot.to_point(WrapPoint::new(new_end, 0), Bias::Left);
                end_bound = Bound::Excluded(new_buffer_end);
                match self.custom_blocks[start_block_ix..].binary_search_by(|probe| {
                    probe
                        .start()
                        .to_point(buffer)
                        .cmp(&new_buffer_end)
                        .then(Ordering::Greater)
                }) {
                    Ok(ix) | Err(ix) => start_block_ix + ix,
                }
            };
            last_block_ix = end_block_ix;

            debug_assert!(blocks_in_edit.is_empty());
            // + 8 is chosen arbitrarily to cover some multibuffer headers
            blocks_in_edit
                .reserve(end_block_ix - start_block_ix + if buffer.is_singleton() { 0 } else { 8 });

            blocks_in_edit.extend(
                self.custom_blocks[start_block_ix..end_block_ix]
                    .iter()
                    .filter_map(|block| {
                        let placement = block.placement.to_wrap_row(wrap_snapshot)?;
                        if !matches!(placement, BlockPlacement::Replace(_))
                            && wrap_snapshot.intersects_fold(Point::new(
                                block
                                    .placement
                                    .start()
                                    .to_point(wrap_snapshot.buffer_snapshot())
                                    .row,
                                0,
                            ))
                        {
                            return None;
                        }
                        if let BlockPlacement::Above(row) = placement
                            && row < new_start
                        {
                            return None;
                        }
                        Some((placement, Block::Custom(block.clone())))
                    }),
            );

            blocks_in_edit.extend(self.header_and_footer_blocks(
                buffer,
                (start_bound, end_bound),
                |point, bias| {
                    wrap_point_cursor
                        .map(
                            tab_point_cursor.map(
                                fold_point_cursor.map(inlay_point_cursor.map(point, bias), bias),
                            ),
                        )
                        .row()
                },
            ));

            if let Some(CompanionView {
                companion_wrap_snapshot: companion_snapshot,
                companion,
                display_map_id,
                ..
            }) = companion_view
            {
                blocks_in_edit.extend(self.spacer_blocks(
                    (start_bound, end_bound),
                    wrap_snapshot,
                    companion_snapshot,
                    companion,
                    display_map_id,
                ));
            }

            BlockMap::sort_blocks(&mut blocks_in_edit);

            // For each of these blocks, insert a new isomorphic transform preceding the block,
            // and then insert the block itself.
            for (block_placement, block) in blocks_in_edit.drain(..) {
                let span =
                    ztracing::debug_span!("for block in edits", block_height = block.height());
                let _enter = span.enter();

                let mut summary = TransformSummary {
                    input_rows: WrapRow(0),
                    output_rows: BlockRow(block.height()),
                    longest_row: BlockRow(0),
                    longest_row_chars: 0,
                    has_replacement_blocks: false,
                };

                let rows_before_block;
                let input_rows = new_transforms.summary().input_rows;
                match &block_placement {
                    &BlockPlacement::Above(position) => {
                        let Some(delta) = position.checked_sub(input_rows) else {
                            continue;
                        };
                        rows_before_block = delta;
                    }
                    &BlockPlacement::Near(position) | &BlockPlacement::Below(position) => {
                        let Some(delta) = (position + RowDelta(1)).checked_sub(input_rows) else {
                            continue;
                        };
                        rows_before_block = delta;
                    }
                    BlockPlacement::Replace(range) => {
                        let Some(delta) = range.start().checked_sub(input_rows) else {
                            continue;
                        };
                        rows_before_block = delta;
                        summary.input_rows = WrapRow(1) + (*range.end() - *range.start());
                    }
                }

                push_isomorphic(&mut new_transforms, rows_before_block, wrap_snapshot);
                new_transforms.push(
                    Transform {
                        summary,
                        block: Some(block),
                    },
                    (),
                );
            }

            // Insert an isomorphic transform after the final block.
            let rows_after_last_block =
                RowDelta(new_end.0).saturating_sub(RowDelta(new_transforms.summary().input_rows.0));
            push_isomorphic(&mut new_transforms, rows_after_last_block, wrap_snapshot);
        }

        new_transforms.append(cursor.suffix(), ());
        debug_assert_eq!(
            new_transforms.summary().input_rows,
            wrap_snapshot.max_point().row() + WrapRow(1),
        );

        drop(cursor);
        *transforms = new_transforms;
    }

    #[ztracing::instrument(skip_all)]
    pub fn replace_blocks(&mut self, mut renderers: HashMap<CustomBlockId, RenderBlock>) {
        for block in &mut self.custom_blocks {
            if let Some(render) = renderers.remove(&block.id) {
                *block.render.lock() = render;
            }
        }
    }

    /// Guarantees that `wrap_row_for` is called with points in increasing order.
    #[ztracing::instrument(skip_all)]
    fn header_and_footer_blocks<'a, R, T>(
        &'a self,
        buffer: &'a multi_buffer::MultiBufferSnapshot,
        range: R,
        mut wrap_row_for: impl 'a + FnMut(Point, Bias) -> WrapRow,
    ) -> impl Iterator<Item = (BlockPlacement<WrapRow>, Block)> + 'a
    where
        R: RangeBounds<T>,
        T: multi_buffer::ToOffset,
    {
        let mut boundaries = buffer.excerpt_boundaries_in_range(range).peekable();

        std::iter::from_fn(move || {
            loop {
                let excerpt_boundary = boundaries.next()?;
                let wrap_row = wrap_row_for(Point::new(excerpt_boundary.row.0, 0), Bias::Left);

                let new_buffer_id = match (&excerpt_boundary.prev, &excerpt_boundary.next) {
                    (None, next) => Some(next.buffer_id()),
                    (Some(prev), next) => {
                        if prev.buffer_id() != next.buffer_id() {
                            Some(next.buffer_id())
                        } else {
                            None
                        }
                    }
                };

                let mut height = 0;

                if let Some(new_buffer_id) = new_buffer_id {
                    let first_excerpt = excerpt_boundary.next.clone();
                    if self.buffers_with_disabled_headers.contains(&new_buffer_id) {
                        continue;
                    }
                    if self.folded_buffers.contains(&new_buffer_id) && buffer.show_headers() {
                        let mut last_excerpt_end_row = first_excerpt.end_row;

                        while let Some(next_boundary) = boundaries.peek() {
                            if next_boundary.next.buffer_id() == new_buffer_id {
                                last_excerpt_end_row = next_boundary.next.end_row;
                            } else {
                                break;
                            }

                            boundaries.next();
                        }
                        let wrap_end_row = wrap_row_for(
                            Point::new(
                                last_excerpt_end_row.0,
                                buffer.line_len(last_excerpt_end_row),
                            ),
                            Bias::Right,
                        );

                        return Some((
                            BlockPlacement::Replace(wrap_row..=wrap_end_row),
                            Block::FoldedBuffer {
                                height: height + self.buffer_header_height,
                                first_excerpt,
                            },
                        ));
                    }
                }

                let starts_new_buffer = new_buffer_id.is_some();
                let block = if starts_new_buffer && buffer.show_headers() {
                    height += self.buffer_header_height;
                    Block::BufferHeader {
                        excerpt: excerpt_boundary.next,
                        height,
                    }
                } else if excerpt_boundary.prev.is_some() {
                    height += self.excerpt_header_height;
                    Block::ExcerptBoundary {
                        excerpt: excerpt_boundary.next,
                        height,
                    }
                } else {
                    continue;
                };

                return Some((BlockPlacement::Above(wrap_row), block));
            }
        })
    }

    fn spacer_blocks(
        &self,
        bounds: (Bound<MultiBufferPoint>, Bound<MultiBufferPoint>),
        wrap_snapshot: &WrapSnapshot,
        companion_snapshot: &WrapSnapshot,
        companion: &Companion,
        display_map_id: EntityId,
    ) -> Vec<(BlockPlacement<WrapRow>, Block)> {
        let our_buffer = wrap_snapshot.buffer_snapshot();
        let companion_buffer = companion_snapshot.buffer_snapshot();

        let range = match bounds {
            (Bound::Included(start), Bound::Excluded(end)) => start..end,
            (Bound::Included(start), Bound::Unbounded) => start..wrap_snapshot.buffer().max_point(),
            _ => unreachable!(),
        };
        let mut patches = companion.convert_rows_to_companion(
            display_map_id,
            companion_buffer,
            our_buffer,
            range,
        );
        if let Some(patch) = patches.last()
            && let Bound::Excluded(end) = bounds.1
            && end == wrap_snapshot.buffer().max_point()
            && patch.source_excerpt_range.is_empty()
        {
            patches.pop();
        }

        let mut our_inlay_point_cursor = wrap_snapshot.inlay_point_cursor();
        let mut our_fold_point_cursor = wrap_snapshot.fold_point_cursor();
        let mut our_tab_point_cursor = wrap_snapshot.tab_point_cursor();
        let mut our_wrap_point_cursor = wrap_snapshot.wrap_point_cursor();

        let mut our_wrapper = |our_point: Point, bias: Bias| {
            our_wrap_point_cursor
                .map(our_tab_point_cursor.map(
                    our_fold_point_cursor.map(our_inlay_point_cursor.map(our_point, bias), bias),
                ))
                .row()
        };
        let mut companion_wrapper = |their_point: Point, bias: Bias| {
            // TODO(split-diff) fix companion points being passed in decreasing order
            let inlay_point = companion_snapshot
                .inlay_snapshot
                .inlay_point_cursor()
                .map(their_point, bias);
            let fold_point = companion_snapshot.to_fold_point(inlay_point, bias);
            let tab_point = companion_snapshot.fold_point_to_tab_point(fold_point);
            companion_snapshot.tab_point_to_wrap_point(tab_point).row()
        };
        fn determine_spacer(
            our_wrapper: &mut dyn FnMut(Point, Bias) -> WrapRow,
            companion_wrapper: &mut dyn FnMut(Point, Bias) -> WrapRow,
            our_point: Point,
            their_point: Point,
            delta: i32,
            bias: Bias,
        ) -> (i32, Option<(WrapRow, u32)>) {
            let our_wrap = our_wrapper(our_point, bias);
            let companion_wrap = companion_wrapper(their_point, bias);
            let new_delta = companion_wrap.0 as i32 - our_wrap.0 as i32;

            let spacer = if new_delta > delta {
                let height = (new_delta - delta) as u32;
                Some((our_wrap, height))
            } else {
                None
            };
            (new_delta, spacer)
        }

        let mut result = Vec::new();

        for excerpt in patches {
            let mut source_points = (excerpt.edited_range.start.row..=excerpt.edited_range.end.row)
                .map(|row| MultiBufferPoint::new(row, 0))
                .chain(if excerpt.edited_range.end.column > 0 {
                    Some(excerpt.edited_range.end)
                } else {
                    None
                })
                .peekable();
            let last_source_point = if excerpt.edited_range.end.column > 0 {
                excerpt.edited_range.end
            } else {
                MultiBufferPoint::new(excerpt.edited_range.end.row, 0)
            };

            let Some(first_point) = source_points.peek().copied() else {
                continue;
            };
            let edit_for_first_point = excerpt.patch.edit_for_old_position(first_point);

            // Because we calculate spacers based on differences in wrap row
            // counts between the RHS and LHS for corresponding buffer points,
            // we need to calibrate our expectations based on the difference
            // in counts before the start of the edit. This difference in
            // counts should have been balanced already by spacers above this
            // edit, so we only need to insert spacers for when the difference
            // in counts diverges from that baseline value.
            let (our_baseline, their_baseline) = if edit_for_first_point.old.start < first_point {
                // Case 1: We are inside a hunk/group--take the start of the hunk/group on both sides as the baseline.
                (
                    edit_for_first_point.old.start,
                    edit_for_first_point.new.start,
                )
            } else if first_point.row > excerpt.source_excerpt_range.start.row {
                // Case 2: We are not inside a hunk/group--go back by one row to find the baseline.
                let prev_point = Point::new(first_point.row - 1, 0);
                let edit_for_prev_point = excerpt.patch.edit_for_old_position(prev_point);
                (prev_point, edit_for_prev_point.new.end)
            } else {
                // Case 3: We are at the start of the excerpt--no previous row to use as the baseline.
                (first_point, edit_for_first_point.new.start)
            };
            let our_baseline = our_wrapper(our_baseline, Bias::Left);
            let their_baseline = companion_wrapper(
                their_baseline.min(excerpt.target_excerpt_range.end),
                Bias::Left,
            );

            let mut delta = their_baseline.0 as i32 - our_baseline.0 as i32;

            while let Some(source_point) = source_points.next() {
                let mut current_boundary = source_point;
                let current_edit = excerpt.patch.edit_for_old_position(current_boundary);
                let current_range = current_edit.new;

                if current_boundary.column > 0 {
                    debug_assert_eq!(current_boundary, excerpt.source_excerpt_range.end);
                    break;
                }

                if current_edit.old.start < current_boundary {
                    while let Some(next_point) = source_points.peek().copied() {
                        let edit_for_next_point = excerpt.patch.edit_for_old_position(next_point);
                        if edit_for_next_point.new.end > current_range.end {
                            break;
                        }
                        current_boundary = next_point;
                        source_points.next();
                    }

                    let (new_delta, spacer) = determine_spacer(
                        &mut our_wrapper,
                        &mut companion_wrapper,
                        current_boundary,
                        current_range.end.min(excerpt.target_excerpt_range.end),
                        delta,
                        Bias::Left,
                    );

                    delta = new_delta;
                    if let Some((wrap_row, height)) = spacer {
                        result.push((
                            BlockPlacement::Above(wrap_row),
                            Block::Spacer {
                                id: SpacerId(self.next_block_id.fetch_add(1, SeqCst)),
                                height,
                                is_below: false,
                            },
                        ));
                    }
                    continue;
                }

                let (delta_at_start, mut spacer_at_start) = determine_spacer(
                    &mut our_wrapper,
                    &mut companion_wrapper,
                    current_boundary,
                    current_range.start.min(excerpt.target_excerpt_range.end),
                    delta,
                    Bias::Left,
                );
                delta = delta_at_start;

                while let Some(next_point) = source_points.peek().copied() {
                    let edit_for_next_point = excerpt.patch.edit_for_old_position(next_point);
                    if edit_for_next_point.new.end > current_range.end {
                        break;
                    }

                    if let Some((wrap_row, height)) = spacer_at_start.take() {
                        result.push((
                            BlockPlacement::Above(wrap_row),
                            Block::Spacer {
                                id: SpacerId(self.next_block_id.fetch_add(1, SeqCst)),
                                height,
                                is_below: false,
                            },
                        ));
                    }

                    current_boundary = next_point;
                    source_points.next();
                }

                if current_boundary.column > 0 {
                    debug_assert_eq!(current_boundary, excerpt.source_excerpt_range.end);
                    break;
                }

                let edit_for_current_boundary =
                    excerpt.patch.edit_for_old_position(current_boundary);

                let spacer_at_end = if current_boundary == edit_for_current_boundary.old.end {
                    let (delta_at_end, spacer_at_end) = determine_spacer(
                        &mut our_wrapper,
                        &mut companion_wrapper,
                        current_boundary,
                        current_range.end.min(excerpt.target_excerpt_range.end),
                        delta,
                        Bias::Left,
                    );
                    delta = delta_at_end;
                    spacer_at_end
                } else {
                    None
                };

                if let Some((wrap_row, mut height)) = spacer_at_start {
                    if let Some((_, additional_height)) = spacer_at_end {
                        height += additional_height;
                    }
                    result.push((
                        BlockPlacement::Above(wrap_row),
                        Block::Spacer {
                            id: SpacerId(self.next_block_id.fetch_add(1, SeqCst)),
                            height,
                            is_below: false,
                        },
                    ));
                } else if let Some((wrap_row, height)) = spacer_at_end {
                    result.push((
                        BlockPlacement::Above(wrap_row),
                        Block::Spacer {
                            id: SpacerId(self.next_block_id.fetch_add(1, SeqCst)),
                            height,
                            is_below: false,
                        },
                    ));
                }
            }

            if last_source_point == excerpt.source_excerpt_range.end {
                let (_new_delta, spacer) = determine_spacer(
                    &mut our_wrapper,
                    &mut companion_wrapper,
                    last_source_point,
                    excerpt.target_excerpt_range.end,
                    delta,
                    Bias::Right,
                );
                if let Some((wrap_row, height)) = spacer {
                    result.push((
                        BlockPlacement::Below(wrap_row),
                        Block::Spacer {
                            id: SpacerId(self.next_block_id.fetch_add(1, SeqCst)),
                            height,
                            is_below: true,
                        },
                    ));
                }
            }
        }

        result
    }

    #[ztracing::instrument(skip_all)]
    fn sort_blocks(blocks: &mut Vec<(BlockPlacement<WrapRow>, Block)>) {
        blocks.sort_unstable_by(|(placement_a, block_a), (placement_b, block_b)| {
            placement_a
                .start()
                .cmp(placement_b.start())
                .then_with(|| placement_b.end().cmp(placement_a.end()))
                .then_with(|| placement_a.tie_break().cmp(&placement_b.tie_break()))
                .then_with(|| {
                    if block_a.is_header() {
                        Ordering::Less
                    } else if block_b.is_header() {
                        Ordering::Greater
                    } else {
                        Ordering::Equal
                    }
                })
                .then_with(|| match (block_a, block_b) {
                    (
                        Block::ExcerptBoundary {
                            excerpt: excerpt_a, ..
                        }
                        | Block::BufferHeader {
                            excerpt: excerpt_a, ..
                        },
                        Block::ExcerptBoundary {
                            excerpt: excerpt_b, ..
                        }
                        | Block::BufferHeader {
                            excerpt: excerpt_b, ..
                        },
                    ) => Some(excerpt_a.start_text_anchor().opaque_id())
                        .cmp(&Some(excerpt_b.start_text_anchor().opaque_id())),
                    (
                        Block::ExcerptBoundary { .. } | Block::BufferHeader { .. },
                        Block::Spacer { .. } | Block::Custom(_),
                    ) => Ordering::Less,
                    (
                        Block::Spacer { .. } | Block::Custom(_),
                        Block::ExcerptBoundary { .. } | Block::BufferHeader { .. },
                    ) => Ordering::Greater,
                    (Block::Spacer { .. }, Block::Custom(_)) => Ordering::Less,
                    (Block::Custom(_), Block::Spacer { .. }) => Ordering::Greater,
                    (Block::Custom(block_a), Block::Custom(block_b)) => block_a
                        .priority
                        .cmp(&block_b.priority)
                        .then_with(|| block_a.id.cmp(&block_b.id)),
                    _ => {
                        unreachable!("comparing blocks: {block_a:?} vs {block_b:?}")
                    }
                })
        });
        blocks.dedup_by(|right, left| match (left.0.clone(), right.0.clone()) {
            (BlockPlacement::Replace(range), BlockPlacement::Above(row))
            | (BlockPlacement::Replace(range), BlockPlacement::Near(row))
            | (BlockPlacement::Replace(range), BlockPlacement::Below(row)) => range.contains(&row),
            (BlockPlacement::Replace(range_a), BlockPlacement::Replace(range_b)) => {
                if range_a.end() >= range_b.start() && range_a.start() <= range_b.end() {
                    left.0 = BlockPlacement::Replace(
                        *range_a.start()..=*range_a.end().max(range_b.end()),
                    );
                    true
                } else {
                    false
                }
            }
            _ => false,
        });
    }
}

#[ztracing::instrument(skip(tree, wrap_snapshot))]
fn push_isomorphic(tree: &mut SumTree<Transform>, rows: RowDelta, wrap_snapshot: &WrapSnapshot) {
    if rows == RowDelta(0) {
        return;
    }

    let wrap_row_start = tree.summary().input_rows;
    let wrap_row_end = wrap_row_start + rows;
    let wrap_summary = wrap_snapshot.text_summary_for_range(wrap_row_start..wrap_row_end);
    let summary = TransformSummary {
        input_rows: WrapRow(rows.0),
        output_rows: BlockRow(rows.0),
        longest_row: BlockRow(wrap_summary.longest_row),
        longest_row_chars: wrap_summary.longest_row_chars,
        has_replacement_blocks: false,
    };
    let mut merged = false;
    tree.update_last(
        |last_transform| {
            if last_transform.block.is_none() {
                last_transform.summary.add_summary(&summary);
                merged = true;
            }
        },
        (),
    );
    if !merged {
        tree.push(
            Transform {
                summary,
                block: None,
            },
            (),
        );
    }
}

impl BlockPoint {
    pub fn new(row: BlockRow, column: u32) -> Self {
        Self(Point::new(row.0, column))
    }
}

impl Deref for BlockPoint {
    type Target = Point;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl std::ops::DerefMut for BlockPoint {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl Deref for BlockMapReader<'_> {
    type Target = BlockSnapshot;

    fn deref(&self) -> &Self::Target {
        &self.snapshot
    }
}

impl DerefMut for BlockMapReader<'_> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.snapshot
    }
}

impl BlockMapReader<'_> {
    #[ztracing::instrument(skip_all)]
    pub fn row_for_block(&self, block_id: CustomBlockId) -> Option<BlockRow> {
        let block = self.blocks.iter().find(|block| block.id == block_id)?;
        let buffer_row = block
            .start()
            .to_point(self.wrap_snapshot.buffer_snapshot())
            .row;
        let wrap_row = self
            .wrap_snapshot
            .make_wrap_point(Point::new(buffer_row, 0), Bias::Left)
            .row();
        let start_wrap_row = self
            .wrap_snapshot
            .prev_row_boundary(WrapPoint::new(wrap_row, 0));
        let end_wrap_row = self
            .wrap_snapshot
            .next_row_boundary(WrapPoint::new(wrap_row, 0))
            .unwrap_or(self.wrap_snapshot.max_point().row() + WrapRow(1));

        let mut cursor = self.transforms.cursor::<Dimensions<WrapRow, BlockRow>>(());
        cursor.seek(&start_wrap_row, Bias::Left);
        while let Some(transform) = cursor.item() {
            if cursor.start().0 > end_wrap_row {
                break;
            }

            if let Some(BlockId::Custom(id)) = transform.block.as_ref().map(|block| block.id())
                && id == block_id
            {
                return Some(cursor.start().1);
            }
            cursor.next();
        }

        None
    }
}

pub(crate) fn balancing_block(
    my_block: &BlockProperties<Anchor>,
    my_snapshot: &MultiBufferSnapshot,
    their_snapshot: &MultiBufferSnapshot,
    my_display_map_id: EntityId,
    companion: &Companion,
) -> Option<BlockProperties<Anchor>> {
    let my_anchor = my_block.placement.start();
    let my_point = my_anchor.to_point(&my_snapshot);
    let their_range = companion.convert_point_to_companion(
        my_display_map_id,
        my_snapshot,
        their_snapshot,
        my_point,
    );
    let their_anchor = their_snapshot.anchor_at(their_range.start, my_anchor.bias());
    let their_placement = match my_block.placement {
        BlockPlacement::Above(_) => BlockPlacement::Above(their_anchor),
        BlockPlacement::Below(_) => {
            if their_range.is_empty() {
                BlockPlacement::Above(their_anchor)
            } else {
                BlockPlacement::Below(their_anchor)
            }
        }
        // Not supported for balancing
        BlockPlacement::Near(_) | BlockPlacement::Replace(_) => return None,
    };
    Some(BlockProperties {
        placement: their_placement,
        height: my_block.height,
        style: BlockStyle::Spacer,
        render: Arc::new(move |cx| {
            crate::EditorElement::render_spacer_block(
                cx.block_id,
                cx.height,
                cx.line_height,
                cx.indent_guide_padding,
                cx.window,
                cx.app,
            )
        }),
        priority: my_block.priority,
    })
}

impl BlockMapWriterCompanion<'_> {
    fn companion_view(&self) -> CompanionView<'_> {
        static EMPTY_PATCH: Patch<WrapRow> = Patch::empty();
        CompanionView {
            display_map_id: self.display_map_id,
            companion_wrap_snapshot: &self.companion_wrap_snapshot,
            companion_wrap_edits: &EMPTY_PATCH,
            companion: self.companion,
        }
    }
}

impl BlockMapWriter<'_> {
    #[ztracing::instrument(skip_all)]
    pub fn insert(
        &mut self,
        blocks: impl IntoIterator<Item = BlockProperties<Anchor>>,
    ) -> Vec<CustomBlockId> {
        let blocks = blocks.into_iter();
        let mut ids = Vec::with_capacity(blocks.size_hint().1.unwrap_or(0));
        let mut edits = Patch::default();
        let wrap_snapshot = self.block_map.wrap_snapshot.borrow().clone();
        let buffer = wrap_snapshot.buffer_snapshot();

        let mut previous_wrap_row_range: Option<Range<WrapRow>> = None;
        let mut companion_blocks = Vec::new();
        for block in blocks {
            if let BlockPlacement::Replace(_) = &block.placement {
                debug_assert!(block.height.unwrap() > 0);
            }

            let id = self.block_map.insert_block_raw(block.clone(), &buffer);
            ids.push(id);

            let start = block.placement.start().to_point(&buffer);
            let end = block.placement.end().to_point(&buffer);
            let start_wrap_row = wrap_snapshot
                .make_wrap_point(Point::new(start.row, 0), Bias::Left)
                .row();
            let end_wrap_row = wrap_snapshot
                .make_wrap_point(Point::new(end.row, 0), Bias::Left)
                .row();

            let (start_row, end_row) = {
                previous_wrap_row_range.take_if(|range| {
                    !range.contains(&start_wrap_row) || !range.contains(&end_wrap_row)
                });
                let range = previous_wrap_row_range.get_or_insert_with(|| {
                    let start_row =
                        wrap_snapshot.prev_row_boundary(WrapPoint::new(start_wrap_row, 0));
                    let end_row = wrap_snapshot
                        .next_row_boundary(WrapPoint::new(end_wrap_row, 0))
                        .unwrap_or(wrap_snapshot.max_point().row() + WrapRow(1));
                    start_row..end_row
                });
                (range.start, range.end)
            };

            // Insert a matching custom block in the companion (if any)
            if let Some(companion) = &mut self.companion
                && companion.inverse.is_some()
            {
                companion_blocks.extend(balancing_block(
                    &block,
                    &buffer,
                    companion.companion_wrap_snapshot.buffer(),
                    companion.display_map_id,
                    companion.companion,
                ));
            }

            edits = edits.compose([Edit {
                old: start_row..end_row,
                new: start_row..end_row,
            }]);
        }

        self.block_map.sync(
            &wrap_snapshot,
            edits,
            self.companion
                .as_ref()
                .map(BlockMapWriterCompanion::companion_view),
        );

        if let Some(companion) = &mut self.companion
            && let Some(inverse) = &mut companion.inverse
        {
            let companion_ids = inverse.companion_writer.insert(companion_blocks);
            companion
                .companion
                .custom_block_to_balancing_block(companion.display_map_id)
                .borrow_mut()
                .extend(ids.iter().copied().zip(companion_ids));
        }

        ids
    }

    #[ztracing::instrument(skip_all)]
    pub fn resize(&mut self, mut heights: HashMap<CustomBlockId, u32>) {
        let wrap_snapshot = self.block_map.wrap_snapshot.borrow().clone();
        let buffer = wrap_snapshot.buffer_snapshot();
        let mut edits = Patch::default();
        let mut last_block_buffer_row = None;

        let mut companion_heights = HashMap::default();
        for block in &mut self.block_map.custom_blocks {
            if let Some(new_height) = heights.remove(&block.id) {
                if let BlockPlacement::Replace(_) = &block.placement {
                    debug_assert!(new_height > 0);
                }

                if block.height != Some(new_height) {
                    let new_block = CustomBlock {
                        id: block.id,
                        placement: block.placement.clone(),
                        height: Some(new_height),
                        style: block.style,
                        render: block.render.clone(),
                        priority: block.priority,
                    };
                    let new_block = Arc::new(new_block);
                    *block = new_block.clone();
                    self.block_map
                        .custom_blocks_by_id
                        .insert(block.id, new_block);

                    if let Some(companion) = &self.companion
                        && companion.inverse.is_some()
                        && let Some(companion_block_id) = companion
                            .companion
                            .custom_block_to_balancing_block(companion.display_map_id)
                            .borrow()
                            .get(&block.id)
                            .copied()
                    {
                        companion_heights.insert(companion_block_id, new_height);
                    }

                    let start_row = block.placement.start().to_point(buffer).row;
                    let end_row = block.placement.end().to_point(buffer).row;
                    if last_block_buffer_row != Some(end_row) {
                        last_block_buffer_row = Some(end_row);
                        let start_wrap_row = wrap_snapshot
                            .make_wrap_point(Point::new(start_row, 0), Bias::Left)
                            .row();
                        let end_wrap_row = wrap_snapshot
                            .make_wrap_point(Point::new(end_row, 0), Bias::Left)
                            .row();
                        let start =
                            wrap_snapshot.prev_row_boundary(WrapPoint::new(start_wrap_row, 0));
                        let end = wrap_snapshot
                            .next_row_boundary(WrapPoint::new(end_wrap_row, 0))
                            .unwrap_or(wrap_snapshot.max_point().row() + WrapRow(1));
                        edits.push(Edit {
                            old: start..end,
                            new: start..end,
                        })
                    }
                }
            }
        }

        self.block_map.sync(
            &wrap_snapshot,
            edits,
            self.companion
                .as_ref()
                .map(BlockMapWriterCompanion::companion_view),
        );
        if let Some(companion) = &mut self.companion
            && let Some(inverse) = &mut companion.inverse
        {
            inverse.companion_writer.resize(companion_heights);
        }
    }

    #[ztracing::instrument(skip_all)]
    pub fn remove(&mut self, block_ids: HashSet<CustomBlockId>) {
        let wrap_snapshot = &*self.block_map.wrap_snapshot.borrow();
        let buffer = wrap_snapshot.buffer_snapshot();
        let mut edits = Patch::default();
        let mut last_block_buffer_row = None;
        let mut previous_wrap_row_range: Option<Range<WrapRow>> = None;
        let mut companion_block_ids: HashSet<CustomBlockId> = HashSet::default();
        self.block_map.custom_blocks.retain(|block| {
            if block_ids.contains(&block.id) {
                let start = block.placement.start().to_point(buffer);
                let end = block.placement.end().to_point(buffer);
                if last_block_buffer_row != Some(end.row) {
                    last_block_buffer_row = Some(end.row);
                    let start_wrap_row = wrap_snapshot
                        .make_wrap_point(Point::new(start.row, 0), Bias::Left)
                        .row();
                    let end_wrap_row = wrap_snapshot
                        .make_wrap_point(Point::new(end.row, 0), Bias::Left)
                        .row();
                    let (start_row, end_row) = {
                        previous_wrap_row_range.take_if(|range| {
                            !range.contains(&start_wrap_row) || !range.contains(&end_wrap_row)
                        });
                        let range = previous_wrap_row_range.get_or_insert_with(|| {
                            let start_row =
                                wrap_snapshot.prev_row_boundary(WrapPoint::new(start_wrap_row, 0));
                            let end_row = wrap_snapshot
                                .next_row_boundary(WrapPoint::new(end_wrap_row, 0))
                                .unwrap_or(wrap_snapshot.max_point().row() + WrapRow(1));
                            start_row..end_row
                        });
                        (range.start, range.end)
                    };

                    edits.push(Edit {
                        old: start_row..end_row,
                        new: start_row..end_row,
                    })
                }
                if let Some(companion) = &self.companion
                    && companion.inverse.is_some()
                {
                    companion_block_ids.extend(
                        companion
                            .companion
                            .custom_block_to_balancing_block(companion.display_map_id)
                            .borrow()
                            .get(&block.id)
                            .copied(),
                    );
                }
                false
            } else {
                true
            }
        });
        self.block_map
            .custom_blocks_by_id
            .retain(|id, _| !block_ids.contains(id));

        self.block_map.sync(
            wrap_snapshot,
            edits,
            self.companion
                .as_ref()
                .map(BlockMapWriterCompanion::companion_view),
        );
        if let Some(companion) = &mut self.companion
            && let Some(inverse) = &mut companion.inverse
        {
            companion
                .companion
                .custom_block_to_balancing_block(companion.display_map_id)
                .borrow_mut()
                .retain(|id, _| !block_ids.contains(&id));
            inverse.companion_writer.remove(companion_block_ids);
        }
    }

    #[ztracing::instrument(skip_all)]
    pub fn remove_intersecting_replace_blocks(
        &mut self,
        ranges: impl IntoIterator<Item = Range<MultiBufferOffset>>,
        inclusive: bool,
    ) {
        let wrap_snapshot = self.block_map.wrap_snapshot.borrow();
        let mut blocks_to_remove = HashSet::default();
        for range in ranges {
            for block in self.blocks_intersecting_buffer_range(range, inclusive) {
                if matches!(block.placement, BlockPlacement::Replace(_)) {
                    blocks_to_remove.insert(block.id);
                }
            }
        }
        drop(wrap_snapshot);
        self.remove(blocks_to_remove);
    }

    pub fn disable_header_for_buffer(&mut self, buffer_id: BufferId) {
        self.block_map
            .buffers_with_disabled_headers
            .insert(buffer_id);
    }

    #[ztracing::instrument(skip_all)]
    pub fn fold_buffers(
        &mut self,
        buffer_ids: impl IntoIterator<Item = BufferId>,
        multi_buffer: &MultiBuffer,
        cx: &App,
    ) {
        self.fold_or_unfold_buffers(true, buffer_ids, multi_buffer, cx);
    }

    #[ztracing::instrument(skip_all)]
    pub fn unfold_buffers(
        &mut self,
        buffer_ids: impl IntoIterator<Item = BufferId>,
        multi_buffer: &MultiBuffer,
        cx: &App,
    ) {
        self.fold_or_unfold_buffers(false, buffer_ids, multi_buffer, cx);
    }

    #[ztracing::instrument(skip_all)]
    fn fold_or_unfold_buffers(
        &mut self,
        fold: bool,
        buffer_ids: impl IntoIterator<Item = BufferId>,
        multi_buffer: &MultiBuffer,
        cx: &App,
    ) {
        let multi_buffer_snapshot = multi_buffer.snapshot(cx);
        let mut ranges = Vec::new();
        let mut companion_buffer_ids = HashSet::default();
        for buffer_id in buffer_ids {
            if fold {
                self.block_map.folded_buffers.insert(buffer_id);
            } else {
                self.block_map.folded_buffers.remove(&buffer_id);
            }
            ranges.extend(multi_buffer_snapshot.range_for_buffer(buffer_id));
            if let Some(companion) = &self.companion
                && companion.inverse.is_some()
            {
                if let Some(diff) = multi_buffer_snapshot.diff_for_buffer_id(buffer_id) {
                    let companion_buffer_id =
                        if companion.companion.is_rhs(companion.display_map_id) {
                            diff.base_text().remote_id()
                        } else {
                            diff.buffer_id()
                        };
                    companion_buffer_ids.insert(companion_buffer_id);
                }
            }
        }
        ranges.sort_unstable_by_key(|range| range.start);

        let mut edits = Patch::default();
        let wrap_snapshot = self.block_map.wrap_snapshot.borrow().clone();
        for range in ranges {
            let last_edit_row = cmp::min(
                wrap_snapshot.make_wrap_point(range.end, Bias::Right).row() + WrapRow(1),
                wrap_snapshot.max_point().row(),
            ) + WrapRow(1);
            let range = wrap_snapshot.make_wrap_point(range.start, Bias::Left).row()..last_edit_row;
            edits.push(Edit {
                old: range.clone(),
                new: range,
            });
        }

        self.block_map.sync(
            &wrap_snapshot,
            edits.clone(),
            self.companion
                .as_ref()
                .map(BlockMapWriterCompanion::companion_view),
        );
        if let Some(companion) = &mut self.companion
            && let Some(inverse) = &mut companion.inverse
        {
            inverse.companion_writer.fold_or_unfold_buffers(
                fold,
                companion_buffer_ids,
                inverse.companion_multibuffer,
                cx,
            );
        }
    }

    #[ztracing::instrument(skip_all)]
    fn blocks_intersecting_buffer_range(
        &self,
        range: Range<MultiBufferOffset>,
        inclusive: bool,
    ) -> &[Arc<CustomBlock>] {
        if range.is_empty() && !inclusive {
            return &[];
        }
        let wrap_snapshot = self.block_map.wrap_snapshot.borrow();
        let buffer = wrap_snapshot.buffer_snapshot();

        let start_block_ix = match self.block_map.custom_blocks.binary_search_by(|block| {
            let block_end = block.end().to_offset(buffer);
            block_end.cmp(&range.start).then(Ordering::Greater)
        }) {
            Ok(ix) | Err(ix) => ix,
        };
        let end_block_ix =
            match self.block_map.custom_blocks[start_block_ix..].binary_search_by(|block| {
                let block_start = block.start().to_offset(buffer);
                block_start.cmp(&range.end).then(if inclusive {
                    Ordering::Less
                } else {
                    Ordering::Greater
                })
            }) {
                Ok(ix) | Err(ix) => ix,
            };

        &self.block_map.custom_blocks[start_block_ix..][..end_block_ix]
    }
}

impl BlockSnapshot {
    #[inline(always)]
    pub fn has_replacement_blocks(&self) -> bool {
        self.transforms.summary().has_replacement_blocks
    }

    #[cfg(test)]
    #[ztracing::instrument(skip_all)]
    pub fn text(&self) -> String {
        self.chunks(
            BlockRow(0)..self.transforms.summary().output_rows,
            LanguageAwareStyling {
                tree_sitter: false,
                diagnostics: false,
            },
            false,
            Highlights::default(),
        )
        .map(|chunk| chunk.text)
        .collect()
    }

    #[ztracing::instrument(skip_all)]
    pub(crate) fn chunks<'a>(
        &'a self,
        rows: Range<BlockRow>,
        language_aware: LanguageAwareStyling,
        masked: bool,
        highlights: Highlights<'a>,
    ) -> BlockChunks<'a> {
        let max_output_row = cmp::min(rows.end, self.transforms.summary().output_rows);

        let mut cursor = self.transforms.cursor::<Dimensions<BlockRow, WrapRow>>(());
        cursor.seek(&rows.start, Bias::Right);
        let transform_output_start = cursor.start().0;
        let transform_input_start = cursor.start().1;

        let mut input_start = transform_input_start;
        let mut input_end = transform_input_start;
        if let Some(transform) = cursor.item()
            && transform.block.is_none()
        {
            input_start += rows.start - transform_output_start;
            input_end += cmp::min(
                rows.end - transform_output_start,
                RowDelta(transform.summary.input_rows.0),
            );
        }

        BlockChunks {
            input_chunks: self.wrap_snapshot.chunks(
                input_start..input_end,
                language_aware,
                highlights,
            ),
            input_chunk: Default::default(),
            transforms: cursor,
            output_row: rows.start,
            line_count_overflow: RowDelta(0),
            max_output_row,
            masked,
        }
    }

    #[ztracing::instrument(skip_all)]
    pub(super) fn row_infos(&self, start_row: BlockRow) -> BlockRows<'_> {
        let mut cursor = self.transforms.cursor::<Dimensions<BlockRow, WrapRow>>(());
        cursor.seek(&start_row, Bias::Right);
        let Dimensions(output_start, input_start, _) = cursor.start();
        let overshoot = if cursor
            .item()
            .is_some_and(|transform| transform.block.is_none())
        {
            start_row - *output_start
        } else {
            RowDelta(0)
        };
        let input_start_row = *input_start + overshoot;
        BlockRows {
            transforms: cursor,
            input_rows: self.wrap_snapshot.row_infos(input_start_row),
            output_row: start_row,
            started: false,
        }
    }

    #[ztracing::instrument(skip_all)]
    pub fn blocks_in_range(
        &self,
        rows: Range<BlockRow>,
    ) -> impl Iterator<Item = (BlockRow, &Block)> {
        let mut cursor = self.transforms.cursor::<BlockRow>(());
        cursor.seek(&rows.start, Bias::Left);
        while *cursor.start() < rows.start && cursor.end() <= rows.start {
            cursor.next();
        }

        std::iter::from_fn(move || {
            while let Some(transform) = cursor.item() {
                let start_row = *cursor.start();
                if start_row > rows.end
                    || (start_row == rows.end
                        && transform
                            .block
                            .as_ref()
                            .is_some_and(|block| block.height() > 0))
                {
                    break;
                }
                if let Some(block) = &transform.block {
                    cursor.next();
                    return Some((start_row, block));
                } else {
                    cursor.next();
                }
            }
            None
        })
    }

    #[ztracing::instrument(skip_all)]
    pub(crate) fn sticky_header_excerpt(&self, position: f64) -> Option<StickyHeaderExcerpt<'_>> {
        let top_row = position as u32;
        let mut cursor = self.transforms.cursor::<BlockRow>(());
        cursor.seek(&BlockRow(top_row), Bias::Right);

        while let Some(transform) = cursor.item() {
            match &transform.block {
                Some(
                    Block::ExcerptBoundary { excerpt, .. } | Block::BufferHeader { excerpt, .. },
                ) => {
                    return Some(StickyHeaderExcerpt { excerpt });
                }
                Some(block) if block.is_buffer_header() => return None,
                _ => {
                    cursor.prev();
                    continue;
                }
            }
        }

        None
    }

    #[ztracing::instrument(skip_all)]
    pub fn block_for_id(&self, block_id: BlockId) -> Option<Block> {
        let buffer = self.wrap_snapshot.buffer_snapshot();
        let wrap_point = match block_id {
            BlockId::Custom(custom_block_id) => {
                let custom_block = self.custom_blocks_by_id.get(&custom_block_id)?;
                return Some(Block::Custom(custom_block.clone()));
            }
            BlockId::ExcerptBoundary(start_anchor) => {
                let start_point = start_anchor.to_point(&buffer);
                self.wrap_snapshot.make_wrap_point(start_point, Bias::Left)
            }
            BlockId::FoldedBuffer(buffer_id) => self.wrap_snapshot.make_wrap_point(
                buffer
                    .anchor_in_excerpt(buffer.excerpts_for_buffer(buffer_id).next()?.context.start)?
                    .to_point(buffer),
                Bias::Left,
            ),
            BlockId::Spacer(_) => return None,
        };
        let wrap_row = wrap_point.row();

        let mut cursor = self.transforms.cursor::<WrapRow>(());
        cursor.seek(&wrap_row, Bias::Left);

        while let Some(transform) = cursor.item() {
            if let Some(block) = transform.block.as_ref() {
                if block.id() == block_id {
                    return Some(block.clone());
                }
            } else if *cursor.start() > wrap_row {
                break;
            }

            cursor.next();
        }

        None
    }

    #[ztracing::instrument(skip_all)]
    pub fn max_point(&self) -> BlockPoint {
        let row = self
            .transforms
            .summary()
            .output_rows
            .saturating_sub(RowDelta(1));
        BlockPoint::new(row, self.line_len(row))
    }

    #[ztracing::instrument(skip_all)]
    pub fn longest_row(&self) -> BlockRow {
        self.transforms.summary().longest_row
    }

    #[ztracing::instrument(skip_all)]
    pub fn longest_row_in_range(&self, range: Range<BlockRow>) -> BlockRow {
        let mut cursor = self.transforms.cursor::<Dimensions<BlockRow, WrapRow>>(());
        cursor.seek(&range.start, Bias::Right);

        let mut longest_row = range.start;
        let mut longest_row_chars = 0;
        if let Some(transform) = cursor.item() {
            if transform.block.is_none() {
                let &Dimensions(output_start, input_start, _) = cursor.start();
                let overshoot = range.start - output_start;
                let wrap_start_row = input_start + WrapRow(overshoot.0);
                let wrap_end_row = cmp::min(
                    input_start + WrapRow((range.end - output_start).0),
                    cursor.end().1,
                );
                let summary = self
                    .wrap_snapshot
                    .text_summary_for_range(wrap_start_row..wrap_end_row);
                longest_row = BlockRow(range.start.0 + summary.longest_row);
                longest_row_chars = summary.longest_row_chars;
            }
            cursor.next();
        }

        let cursor_start_row = cursor.start().0;
        if range.end > cursor_start_row {
            let summary = cursor.summary::<_, TransformSummary>(&range.end, Bias::Right);
            if summary.longest_row_chars > longest_row_chars {
                longest_row = cursor_start_row + summary.longest_row;
                longest_row_chars = summary.longest_row_chars;
            }

            if let Some(transform) = cursor.item()
                && transform.block.is_none()
            {
                let &Dimensions(output_start, input_start, _) = cursor.start();
                let overshoot = range.end - output_start;
                let wrap_start_row = input_start;
                let wrap_end_row = input_start + overshoot;
                let summary = self
                    .wrap_snapshot
                    .text_summary_for_range(wrap_start_row..wrap_end_row);
                if summary.longest_row_chars > longest_row_chars {
                    longest_row = output_start + RowDelta(summary.longest_row);
                }
            }
        }

        longest_row
    }

    #[ztracing::instrument(skip_all)]
    pub(super) fn line_len(&self, row: BlockRow) -> u32 {
        let (start, _, item) =
            self.transforms
                .find::<Dimensions<BlockRow, WrapRow>, _>((), &row, Bias::Right);
        if let Some(transform) = item {
            let Dimensions(output_start, input_start, _) = start;
            let overshoot = row - output_start;
            if transform.block.is_some() {
                0
            } else {
                self.wrap_snapshot.line_len(input_start + overshoot)
            }
        } else if row == BlockRow(0) {
            0
        } else {
            panic!("row out of range");
        }
    }

    #[ztracing::instrument(skip_all)]
    pub(super) fn is_block_line(&self, row: BlockRow) -> bool {
        let (_, _, item) = self.transforms.find::<BlockRow, _>((), &row, Bias::Right);
        item.is_some_and(|t| t.block.is_some())
    }

    #[ztracing::instrument(skip_all)]
    pub(super) fn is_folded_buffer_header(&self, row: BlockRow) -> bool {
        let (_, _, item) = self.transforms.find::<BlockRow, _>((), &row, Bias::Right);
        let Some(transform) = item else {
            return false;
        };
        matches!(transform.block, Some(Block::FoldedBuffer { .. }))
    }

    #[ztracing::instrument(skip_all)]
    pub(super) fn is_line_replaced(&self, row: MultiBufferRow) -> bool {
        let wrap_point = self
            .wrap_snapshot
            .make_wrap_point(Point::new(row.0, 0), Bias::Left);
        let (_, _, item) = self
            .transforms
            .find::<WrapRow, _>((), &wrap_point.row(), Bias::Right);
        item.is_some_and(|transform| {
            transform
                .block
                .as_ref()
                .is_some_and(|block| block.is_replacement())
        })
    }

    #[ztracing::instrument(skip_all)]
    pub fn clip_point(&self, point: BlockPoint, bias: Bias) -> BlockPoint {
        let mut cursor = self.transforms.cursor::<Dimensions<BlockRow, WrapRow>>(());
        cursor.seek(&BlockRow(point.row), Bias::Right);

        let max_input_row = self.transforms.summary().input_rows;
        let mut search_left = (bias == Bias::Left && cursor.start().1 > WrapRow(0))
            || cursor.end().1 == max_input_row;
        let mut reversed = false;

        loop {
            if let Some(transform) = cursor.item() {
                let Dimensions(output_start_row, input_start_row, _) = cursor.start();
                let Dimensions(output_end_row, input_end_row, _) = cursor.end();
                let output_start = Point::new(output_start_row.0, 0);
                let input_start = Point::new(input_start_row.0, 0);
                let input_end = Point::new(input_end_row.0, 0);

                match transform.block.as_ref() {
                    Some(block) => {
                        if block.is_replacement()
                            && (((bias == Bias::Left || search_left) && output_start <= point.0)
                                || (!search_left && output_start >= point.0))
                        {
                            return BlockPoint(output_start);
                        }
                    }
                    None => {
                        let input_point = if point.row >= output_end_row.0 {
                            let line_len = self.wrap_snapshot.line_len(input_end_row - RowDelta(1));
                            self.wrap_snapshot.clip_point(
                                WrapPoint::new(input_end_row - RowDelta(1), line_len),
                                bias,
                            )
                        } else {
                            let output_overshoot = point.0.saturating_sub(output_start);
                            self.wrap_snapshot
                                .clip_point(WrapPoint(input_start + output_overshoot), bias)
                        };

                        if (input_start..input_end).contains(&input_point.0) {
                            let input_overshoot = input_point.0.saturating_sub(input_start);
                            return BlockPoint(output_start + input_overshoot);
                        }
                    }
                }

                if search_left {
                    cursor.prev();
                } else {
                    cursor.next();
                }
            } else if reversed {
                return self.max_point();
            } else {
                reversed = true;
                search_left = !search_left;
                cursor.seek(&BlockRow(point.row), Bias::Right);
            }
        }
    }

    pub fn block_point_cursor(&self) -> BlockPointCursor<'_> {
        BlockPointCursor {
            snapshot: self,
            cursor: self.transforms.cursor::<Dimensions<WrapRow, BlockRow>>(()),
        }
    }

    #[ztracing::instrument(skip_all)]
    pub fn to_block_point(&self, wrap_point: WrapPoint) -> BlockPoint {
        let (start, _, item) = self.transforms.find::<Dimensions<WrapRow, BlockRow>, _>(
            (),
            &wrap_point.row(),
            Bias::Right,
        );
        if let Some(transform) = item {
            if transform.block.is_some() {
                BlockPoint::new(start.1, 0)
            } else {
                let Dimensions(input_start_row, output_start_row, _) = start;
                let input_start = Point::new(input_start_row.0, 0);
                let output_start = Point::new(output_start_row.0, 0);
                let input_overshoot = wrap_point.0 - input_start;
                BlockPoint(output_start + input_overshoot)
            }
        } else {
            self.max_point()
        }
    }

    #[ztracing::instrument(skip_all)]
    pub fn to_wrap_point(&self, block_point: BlockPoint, bias: Bias) -> WrapPoint {
        let (start, end, item) = self.transforms.find::<Dimensions<BlockRow, WrapRow>, _>(
            (),
            &BlockRow(block_point.row),
            Bias::Right,
        );
        if let Some(transform) = item {
            match transform.block.as_ref() {
                Some(block) => {
                    if block.place_below() {
                        let wrap_row = start.1 - RowDelta(1);
                        WrapPoint::new(wrap_row, self.wrap_snapshot.line_len(wrap_row))
                    } else if block.place_above() {
                        WrapPoint::new(start.1, 0)
                    } else if bias == Bias::Left {
                        WrapPoint::new(start.1, 0)
                    } else {
                        let wrap_row = end.1 - RowDelta(1);
                        WrapPoint::new(wrap_row, self.wrap_snapshot.line_len(wrap_row))
                    }
                }
                None => {
                    let overshoot = block_point.row() - start.0;
                    let wrap_row = start.1 + RowDelta(overshoot.0);
                    WrapPoint::new(wrap_row, block_point.column)
                }
            }
        } else {
            self.wrap_snapshot.max_point()
        }
    }

    pub(super) fn replacement_block_input_range(&self, row: WrapRow) -> Option<Range<WrapRow>> {
        let (start, end, item) = self.transforms.find::<WrapRow, _>((), &row, Bias::Right);
        item?.block.as_ref()?.is_replacement().then_some(start..end)
    }
}

impl BlockChunks<'_> {
    /// Go to the next transform
    #[ztracing::instrument(skip_all)]
    fn advance(&mut self) {
        self.input_chunk = Chunk::default();
        self.transforms.next();
        while let Some(transform) = self.transforms.item() {
            if transform
                .block
                .as_ref()
                .is_some_and(|block| block.height() == 0)
            {
                self.transforms.next();
            } else {
                break;
            }
        }

        if self
            .transforms
            .item()
            .is_some_and(|transform| transform.block.is_none())
        {
            let start_input_row = self.transforms.start().1;
            let start_output_row = self.transforms.start().0;
            if start_output_row < self.max_output_row {
                let end_input_row = cmp::min(
                    self.transforms.end().1,
                    start_input_row + (self.max_output_row - start_output_row),
                );
                self.input_chunks.seek(start_input_row..end_input_row);
            }
        }
    }
}

pub struct StickyHeaderExcerpt<'a> {
    pub excerpt: &'a ExcerptBoundaryInfo,
}

impl<'a> Iterator for BlockChunks<'a> {
    type Item = Chunk<'a>;

    #[ztracing::instrument(skip_all)]
    fn next(&mut self) -> Option<Self::Item> {
        if self.output_row >= self.max_output_row {
            return None;
        }

        if self.line_count_overflow > RowDelta(0) {
            let lines = self.line_count_overflow.0.min(u128::BITS);
            self.line_count_overflow.0 -= lines;
            self.output_row += RowDelta(lines);
            return Some(Chunk {
                text: unsafe { std::str::from_utf8_unchecked(&NEWLINES[..lines as usize]) },
                chars: 1u128.unbounded_shl(lines).wrapping_sub(1),
                ..Default::default()
            });
        }

        let transform = self.transforms.item()?;
        if transform.block.is_some() {
            let block_start = self.transforms.start().0;
            let mut block_end = self.transforms.end().0;
            self.advance();
            if self.transforms.item().is_none() {
                block_end -= RowDelta(1);
            }

            let start_in_block = self.output_row - block_start;
            let end_in_block = cmp::min(self.max_output_row, block_end) - block_start;
            let line_count = end_in_block - start_in_block;
            let lines = RowDelta(line_count.0.min(u128::BITS));
            self.line_count_overflow = line_count - lines;
            self.output_row += lines;

            return Some(Chunk {
                text: unsafe { std::str::from_utf8_unchecked(&NEWLINES[..lines.0 as usize]) },
                chars: 1u128.unbounded_shl(lines.0).wrapping_sub(1),
                ..Default::default()
            });
        }

        if self.input_chunk.text.is_empty() {
            if let Some(input_chunk) = self.input_chunks.next() {
                self.input_chunk = input_chunk;
            } else {
                if self.output_row < self.max_output_row {
                    self.output_row.0 += 1;
                    self.advance();
                    if self.transforms.item().is_some() {
                        return Some(Chunk {
                            text: "\n",
                            chars: 1,
                            ..Default::default()
                        });
                    }
                }
                return None;
            }
        }

        let transform_end = self.transforms.end().0;
        let (prefix_rows, prefix_bytes) =
            offset_for_row(self.input_chunk.text, transform_end - self.output_row);
        self.output_row += prefix_rows;

        let (mut prefix, suffix) = self.input_chunk.text.split_at(prefix_bytes);
        self.input_chunk.text = suffix;
        self.input_chunk.tabs >>= prefix_bytes.saturating_sub(1);
        self.input_chunk.chars >>= prefix_bytes.saturating_sub(1);
        self.input_chunk.newlines >>= prefix_bytes.saturating_sub(1);

        let mut tabs = self.input_chunk.tabs;
        let mut chars = self.input_chunk.chars;
        let mut newlines = self.input_chunk.newlines;

        if self.masked {
            // Not great for multibyte text because to keep cursor math correct we
            // need to have the same number of chars in the input as output.
            let chars_count = prefix.chars().count();
            let bullet_len = chars_count;
            prefix = unsafe { std::str::from_utf8_unchecked(&BULLETS[..bullet_len]) };
            chars = 1u128.unbounded_shl(bullet_len as u32).wrapping_sub(1);
            tabs = 0;
            newlines = 0;
        }

        let chunk = Chunk {
            text: prefix,
            tabs,
            chars,
            newlines,
            ..self.input_chunk.clone()
        };

        if self.output_row == transform_end {
            self.advance();
        }

        Some(chunk)
    }
}

impl Iterator for BlockRows<'_> {
    type Item = RowInfo;

    #[ztracing::instrument(skip_all)]
    fn next(&mut self) -> Option<Self::Item> {
        if self.started {
            self.output_row.0 += 1;
        } else {
            self.started = true;
        }

        if self.output_row >= self.transforms.end().0 {
            self.transforms.next();
            while let Some(transform) = self.transforms.item() {
                if transform
                    .block
                    .as_ref()
                    .is_some_and(|block| block.height() == 0)
                {
                    self.transforms.next();
                } else {
                    break;
                }
            }

            let transform = self.transforms.item()?;
            if transform
                .block
                .as_ref()
                .is_none_or(|block| block.is_replacement())
            {
                self.input_rows.seek(self.transforms.start().1);
            }
        }

        let transform = self.transforms.item()?;
        if transform.block.as_ref().is_none_or(|block| {
            block.is_replacement()
                && self.transforms.start().0 == self.output_row
                && matches!(block, Block::FoldedBuffer { .. }).not()
        }) {
            self.input_rows.next()
        } else {
            Some(RowInfo::default())
        }
    }
}

impl sum_tree::Item for Transform {
    type Summary = TransformSummary;

    fn summary(&self, _cx: ()) -> Self::Summary {
        let mut summary = self.summary.clone();
        summary.has_replacement_blocks = self.block.as_ref().is_some_and(Block::is_replacement);
        summary
    }
}

impl sum_tree::ContextLessSummary for TransformSummary {
    fn zero() -> Self {
        Default::default()
    }

    fn add_summary(&mut self, summary: &Self) {
        if summary.longest_row_chars > self.longest_row_chars {
            self.longest_row = self.output_rows + summary.longest_row;
            self.longest_row_chars = summary.longest_row_chars;
        }
        self.input_rows += summary.input_rows;
        self.output_rows += summary.output_rows;
        self.has_replacement_blocks |= summary.has_replacement_blocks;
    }
}

impl<'a> sum_tree::Dimension<'a, TransformSummary> for WrapRow {
    fn zero(_cx: ()) -> Self {
        Default::default()
    }

    fn add_summary(&mut self, summary: &'a TransformSummary, _: ()) {
        *self += summary.input_rows;
    }
}

impl<'a> sum_tree::Dimension<'a, TransformSummary> for BlockRow {
    fn zero(_cx: ()) -> Self {
        Default::default()
    }

    fn add_summary(&mut self, summary: &'a TransformSummary, _: ()) {
        *self += summary.output_rows;
    }
}

impl Deref for BlockContext<'_, '_> {
    type Target = App;

    fn deref(&self) -> &Self::Target {
        self.app
    }
}

impl DerefMut for BlockContext<'_, '_> {
    fn deref_mut(&mut self) -> &mut Self::Target {
        self.app
    }
}

impl CustomBlock {
    #[ztracing::instrument(skip_all)]
    pub fn render(&self, cx: &mut BlockContext) -> AnyElement {
        self.render.lock()(cx)
    }

    #[ztracing::instrument(skip_all)]
    pub fn start(&self) -> Anchor {
        *self.placement.start()
    }

    #[ztracing::instrument(skip_all)]
    pub fn end(&self) -> Anchor {
        *self.placement.end()
    }

    pub fn style(&self) -> BlockStyle {
        self.style
    }

    pub fn properties(&self) -> BlockProperties<Anchor> {
        BlockProperties {
            placement: self.placement.clone(),
            height: self.height,
            style: self.style,
            render: Arc::new(|_| {
                // Not used
                gpui::Empty.into_any_element()
            }),
            priority: self.priority,
        }
    }
}

impl Debug for CustomBlock {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Block")
            .field("id", &self.id)
            .field("placement", &self.placement)
            .field("height", &self.height)
            .field("style", &self.style)
            .field("priority", &self.priority)
            .finish_non_exhaustive()
    }
}

// Count the number of bytes prior to a target point. If the string doesn't contain the target
// point, return its total extent. Otherwise return the target point itself.
fn offset_for_row(s: &str, target: RowDelta) -> (RowDelta, usize) {
    let mut row = 0;
    let mut offset = 0;
    for (ix, line) in s.split('\n').enumerate() {
        if ix > 0 {
            row += 1;
            offset += 1;
        }
        if row >= target.0 {
            break;
        }
        offset += line.len();
    }
    (RowDelta(row), offset)
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{
        display_map::{
            Companion, DisplayMap, fold_map::FoldMap, fold_map::FoldPlaceholder,
            inlay_map::InlayMap, tab_map::TabMap, wrap_map::WrapMap,
        },
        test::test_font,
    };
    use buffer_diff::BufferDiff;
    use gpui::{App, AppContext as _, Element, div, font, px};
    use itertools::Itertools;
    use language::{Buffer, Capability, Point};
    use multi_buffer::{MultiBuffer, PathKey};
    use project::project_settings::DiagnosticSeverity;
    use rand::prelude::*;
    use settings::SettingsStore;
    use std::env;
    use util::RandomCharIter;

    #[gpui::test]
    fn test_offset_for_row() {
        assert_eq!(offset_for_row("", RowDelta(0)), (RowDelta(0), 0));
        assert_eq!(offset_for_row("", RowDelta(1)), (RowDelta(0), 0));
        assert_eq!(offset_for_row("abcd", RowDelta(0)), (RowDelta(0), 0));
        assert_eq!(offset_for_row("abcd", RowDelta(1)), (RowDelta(0), 4));
        assert_eq!(offset_for_row("\n", RowDelta(0)), (RowDelta(0), 0));
        assert_eq!(offset_for_row("\n", RowDelta(1)), (RowDelta(1), 1));
        assert_eq!(
            offset_for_row("abc\ndef\nghi", RowDelta(0)),
            (RowDelta(0), 0)
        );
        assert_eq!(
            offset_for_row("abc\ndef\nghi", RowDelta(1)),
            (RowDelta(1), 4)
        );
        assert_eq!(
            offset_for_row("abc\ndef\nghi", RowDelta(2)),
            (RowDelta(2), 8)
        );
        assert_eq!(
            offset_for_row("abc\ndef\nghi", RowDelta(3)),
            (RowDelta(2), 11)
        );
    }

    #[gpui::test]
    fn test_basic_blocks(cx: &mut gpui::TestAppContext) {
        cx.update(init_test);

        let text = "aaa\nbbb\nccc\nddd";

        let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));
        let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
        let subscription = buffer.update(cx, |buffer, _| buffer.subscribe());
        let (mut inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
        let (mut fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot);
        let (mut tab_map, tab_snapshot) = TabMap::new(fold_snapshot, 1.try_into().unwrap());
        let (wrap_map, wraps_snapshot) =
            cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
        let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);

        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
        let block_ids = writer.insert(vec![
            BlockProperties {
                style: BlockStyle::Fixed,
                placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(1, 0))),
                height: Some(1),
                render: Arc::new(|_| div().into_any()),
                priority: 0,
            },
            BlockProperties {
                style: BlockStyle::Fixed,
                placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(1, 2))),
                height: Some(2),
                render: Arc::new(|_| div().into_any()),
                priority: 0,
            },
            BlockProperties {
                style: BlockStyle::Fixed,
                placement: BlockPlacement::Below(buffer_snapshot.anchor_after(Point::new(3, 3))),
                height: Some(3),
                render: Arc::new(|_| div().into_any()),
                priority: 0,
            },
        ]);

        let snapshot = block_map.read(wraps_snapshot, Default::default(), None);
        assert_eq!(snapshot.text(), "aaa\n\n\n\nbbb\nccc\nddd\n\n\n");

        let blocks = snapshot
            .blocks_in_range(BlockRow(0)..BlockRow(8))
            .map(|(start_row, block)| {
                let block = block.as_custom().unwrap();
                (start_row.0..start_row.0 + block.height.unwrap(), block.id)
            })
            .collect::<Vec<_>>();

        // When multiple blocks are on the same line, the newer blocks appear first.
        assert_eq!(
            blocks,
            &[
                (1..2, block_ids[0]),
                (2..4, block_ids[1]),
                (7..10, block_ids[2]),
            ]
        );

        assert_eq!(
            snapshot.to_block_point(WrapPoint::new(WrapRow(0), 3)),
            BlockPoint::new(BlockRow(0), 3)
        );
        assert_eq!(
            snapshot.to_block_point(WrapPoint::new(WrapRow(1), 0)),
            BlockPoint::new(BlockRow(4), 0)
        );
        assert_eq!(
            snapshot.to_block_point(WrapPoint::new(WrapRow(3), 3)),
            BlockPoint::new(BlockRow(6), 3)
        );

        assert_eq!(
            snapshot.to_wrap_point(BlockPoint::new(BlockRow(0), 3), Bias::Left),
            WrapPoint::new(WrapRow(0), 3)
        );
        assert_eq!(
            snapshot.to_wrap_point(BlockPoint::new(BlockRow(1), 0), Bias::Left),
            WrapPoint::new(WrapRow(1), 0)
        );
        assert_eq!(
            snapshot.to_wrap_point(BlockPoint::new(BlockRow(3), 0), Bias::Left),
            WrapPoint::new(WrapRow(1), 0)
        );
        assert_eq!(
            snapshot.to_wrap_point(BlockPoint::new(BlockRow(7), 0), Bias::Left),
            WrapPoint::new(WrapRow(3), 3)
        );

        assert_eq!(
            snapshot.clip_point(BlockPoint::new(BlockRow(1), 0), Bias::Left),
            BlockPoint::new(BlockRow(0), 3)
        );
        assert_eq!(
            snapshot.clip_point(BlockPoint::new(BlockRow(1), 0), Bias::Right),
            BlockPoint::new(BlockRow(4), 0)
        );
        assert_eq!(
            snapshot.clip_point(BlockPoint::new(BlockRow(1), 1), Bias::Left),
            BlockPoint::new(BlockRow(0), 3)
        );
        assert_eq!(
            snapshot.clip_point(BlockPoint::new(BlockRow(1), 1), Bias::Right),
            BlockPoint::new(BlockRow(4), 0)
        );
        assert_eq!(
            snapshot.clip_point(BlockPoint::new(BlockRow(4), 0), Bias::Left),
            BlockPoint::new(BlockRow(4), 0)
        );
        assert_eq!(
            snapshot.clip_point(BlockPoint::new(BlockRow(4), 0), Bias::Right),
            BlockPoint::new(BlockRow(4), 0)
        );
        assert_eq!(
            snapshot.clip_point(BlockPoint::new(BlockRow(6), 3), Bias::Left),
            BlockPoint::new(BlockRow(6), 3)
        );
        assert_eq!(
            snapshot.clip_point(BlockPoint::new(BlockRow(6), 3), Bias::Right),
            BlockPoint::new(BlockRow(6), 3)
        );
        assert_eq!(
            snapshot.clip_point(BlockPoint::new(BlockRow(7), 0), Bias::Left),
            BlockPoint::new(BlockRow(6), 3)
        );
        assert_eq!(
            snapshot.clip_point(BlockPoint::new(BlockRow(7), 0), Bias::Right),
            BlockPoint::new(BlockRow(6), 3)
        );

        assert_eq!(
            snapshot
                .row_infos(BlockRow(0))
                .map(|row_info| row_info.buffer_row)
                .collect::<Vec<_>>(),
            &[
                Some(0),
                None,
                None,
                None,
                Some(1),
                Some(2),
                Some(3),
                None,
                None,
                None
            ]
        );

        // Insert a line break, separating two block decorations into separate lines.
        let buffer_snapshot = buffer.update(cx, |buffer, cx| {
            buffer.edit([(Point::new(1, 1)..Point::new(1, 1), "!!!\n")], None, cx);
            buffer.snapshot(cx)
        });

        let (inlay_snapshot, inlay_edits) =
            inlay_map.sync(buffer_snapshot, subscription.consume().into_inner());
        let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
        let (tab_snapshot, tab_edits) =
            tab_map.sync(fold_snapshot, fold_edits, 4.try_into().unwrap());
        let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
            wrap_map.sync(tab_snapshot, tab_edits, cx)
        });
        let snapshot = block_map.read(wraps_snapshot, wrap_edits, None);
        assert_eq!(snapshot.text(), "aaa\n\nb!!!\n\n\nbb\nccc\nddd\n\n\n");
    }

    #[gpui::test]
    fn test_blocks_hidden_in_folds(cx: &mut gpui::TestAppContext) {
        cx.update(init_test);

        let text = "line0\nline1\nline2\nline3\nline4";

        let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));
        let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
        let tab_size = 1.try_into().unwrap();
        let (mut inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
        let (mut fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot);
        let (mut tab_map, tab_snapshot) = TabMap::new(fold_snapshot, tab_size);
        let (wrap_map, wraps_snapshot) =
            cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
        let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);

        let above = |row| BlockProperties {
            style: BlockStyle::Fixed,
            placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(row, 0))),
            height: Some(1),
            render: Arc::new(|_| div().into_any()),
            priority: 0,
        };
        let below = |row| BlockProperties {
            placement: BlockPlacement::Below(buffer_snapshot.anchor_after(Point::new(row, 0))),
            ..above(row)
        };

        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
        let block_ids = writer.insert(vec![above(1), above(2), below(2), above(4)]);
        let (block_a, block_b, block_c, block_d) =
            (block_ids[0], block_ids[1], block_ids[2], block_ids[3]);

        let present_blocks =
            |block_map: &mut BlockMap, wraps_snapshot: WrapSnapshot, wrap_edits: WrapPatch| {
                let snapshot = block_map.read(wraps_snapshot, wrap_edits, None);
                let max_row = snapshot.max_point().row;
                snapshot
                    .blocks_in_range(BlockRow(0)..BlockRow(max_row + 1))
                    .filter_map(|(_, block)| Some(block.as_custom()?.id))
                    .collect::<HashSet<_>>()
            };

        assert_eq!(
            present_blocks(&mut block_map, wraps_snapshot, Default::default()),
            HashSet::from_iter([block_a, block_b, block_c, block_d]),
            "every block is present before folding",
        );

        // Fold lines 2 and 3 entirely, leaving line1 (the fold start) visible.
        let (inlay_snapshot, inlay_edits) = inlay_map.sync(buffer_snapshot.clone(), vec![]);
        let (mut fold_writer, _, _) = fold_map.write(inlay_snapshot, inlay_edits);
        let (fold_snapshot, fold_edits) = fold_writer.fold(vec![(
            Point::new(1, 5)..Point::new(3, 5),
            FoldPlaceholder::test(),
        )]);
        let (tab_snapshot, tab_edits) = tab_map.sync(fold_snapshot, fold_edits, tab_size);
        let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
            wrap_map.sync(tab_snapshot, tab_edits, cx)
        });

        assert_eq!(
            present_blocks(&mut block_map, wraps_snapshot, wrap_edits),
            HashSet::from_iter([block_a, block_d]),
            "blocks B and C anchored to folded lines are dropped, A (fold-start line) and D (past the fold) stay",
        );
    }

    #[gpui::test]
    fn test_multibuffer_headers_and_footers(cx: &mut App) {
        init_test(cx);

        let buffer1 = cx.new(|cx| Buffer::local("Buffer 1", cx));
        let buffer2 = cx.new(|cx| Buffer::local("Buffer 2", cx));
        let buffer3 = cx.new(|cx| Buffer::local("Buffer 3", cx));

        let multi_buffer = cx.new(|cx| {
            let mut multi_buffer = MultiBuffer::new(Capability::ReadWrite);
            multi_buffer.set_excerpts_for_path(
                PathKey::sorted(0),
                buffer1.clone(),
                [Point::zero()..buffer1.read(cx).max_point()],
                0,
                cx,
            );
            multi_buffer.set_excerpts_for_path(
                PathKey::sorted(1),
                buffer2.clone(),
                [Point::zero()..buffer2.read(cx).max_point()],
                0,
                cx,
            );
            multi_buffer.set_excerpts_for_path(
                PathKey::sorted(2),
                buffer3.clone(),
                [Point::zero()..buffer3.read(cx).max_point()],
                0,
                cx,
            );
            multi_buffer
        });
        let excerpt_start_anchors = multi_buffer.read_with(cx, |mb, _| {
            let snapshot = mb.snapshot(cx);
            snapshot
                .excerpts()
                .map(|e| snapshot.anchor_in_excerpt(e.context.start).unwrap())
                .collect::<Vec<_>>()
        });

        let font = test_font();
        let font_size = px(14.);
        let font_id = cx.text_system().resolve_font(&font);
        let mut wrap_width = px(0.);
        for c in "Buff".chars() {
            wrap_width += cx
                .text_system()
                .advance(font_id, font_size, c)
                .unwrap()
                .width;
        }

        let multi_buffer_snapshot = multi_buffer.read(cx).snapshot(cx);
        let (_, inlay_snapshot) = InlayMap::new(multi_buffer_snapshot);
        let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
        let (_, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
        let (_, wraps_snapshot) = WrapMap::new(tab_snapshot, font, font_size, Some(wrap_width), cx);

        let block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
        let snapshot = block_map.read(wraps_snapshot, Default::default(), None);

        // Each excerpt has a header above and footer below. Excerpts are also *separated* by a newline.
        assert_eq!(snapshot.text(), "\nBuff\ner 1\n\nBuff\ner 2\n\nBuff\ner 3");

        let blocks: Vec<_> = snapshot
            .blocks_in_range(BlockRow(0)..BlockRow(u32::MAX))
            .map(|(row, block)| (row.0..row.0 + block.height(), block.id()))
            .collect();
        assert_eq!(
            blocks,
            vec![
                (0..1, BlockId::ExcerptBoundary(excerpt_start_anchors[0])), // path, header
                (3..4, BlockId::ExcerptBoundary(excerpt_start_anchors[1])), // path, header
                (6..7, BlockId::ExcerptBoundary(excerpt_start_anchors[2])), // path, header
            ]
        );
    }

    #[gpui::test]
    fn test_replace_with_heights(cx: &mut gpui::TestAppContext) {
        cx.update(init_test);

        let text = "aaa\nbbb\nccc\nddd";

        let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));
        let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
        let _subscription = buffer.update(cx, |buffer, _| buffer.subscribe());
        let (_inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
        let (_fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot);
        let (_tab_map, tab_snapshot) = TabMap::new(fold_snapshot, 1.try_into().unwrap());
        let (_wrap_map, wraps_snapshot) =
            cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
        let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);

        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
        let block_ids = writer.insert(vec![
            BlockProperties {
                style: BlockStyle::Fixed,
                placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(1, 0))),
                height: Some(1),
                render: Arc::new(|_| div().into_any()),
                priority: 0,
            },
            BlockProperties {
                style: BlockStyle::Fixed,
                placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(1, 2))),
                height: Some(2),
                render: Arc::new(|_| div().into_any()),
                priority: 0,
            },
            BlockProperties {
                style: BlockStyle::Fixed,
                placement: BlockPlacement::Below(buffer_snapshot.anchor_after(Point::new(3, 3))),
                height: Some(3),
                render: Arc::new(|_| div().into_any()),
                priority: 0,
            },
        ]);

        {
            let snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
            assert_eq!(snapshot.text(), "aaa\n\n\n\nbbb\nccc\nddd\n\n\n");

            let mut block_map_writer =
                block_map.write(wraps_snapshot.clone(), Default::default(), None);

            let mut new_heights = HashMap::default();
            new_heights.insert(block_ids[0], 2);
            block_map_writer.resize(new_heights);
            let snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
            assert_eq!(snapshot.text(), "aaa\n\n\n\n\nbbb\nccc\nddd\n\n\n");
        }

        {
            let mut block_map_writer =
                block_map.write(wraps_snapshot.clone(), Default::default(), None);

            let mut new_heights = HashMap::default();
            new_heights.insert(block_ids[0], 1);
            block_map_writer.resize(new_heights);

            let snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
            assert_eq!(snapshot.text(), "aaa\n\n\n\nbbb\nccc\nddd\n\n\n");
        }

        {
            let mut block_map_writer =
                block_map.write(wraps_snapshot.clone(), Default::default(), None);

            let mut new_heights = HashMap::default();
            new_heights.insert(block_ids[0], 0);
            block_map_writer.resize(new_heights);

            let snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
            assert_eq!(snapshot.text(), "aaa\n\n\nbbb\nccc\nddd\n\n\n");
        }

        {
            let mut block_map_writer =
                block_map.write(wraps_snapshot.clone(), Default::default(), None);

            let mut new_heights = HashMap::default();
            new_heights.insert(block_ids[0], 3);
            block_map_writer.resize(new_heights);

            let snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
            assert_eq!(snapshot.text(), "aaa\n\n\n\n\n\nbbb\nccc\nddd\n\n\n");
        }

        {
            let mut block_map_writer =
                block_map.write(wraps_snapshot.clone(), Default::default(), None);

            let mut new_heights = HashMap::default();
            new_heights.insert(block_ids[0], 3);
            block_map_writer.resize(new_heights);

            let snapshot = block_map.read(wraps_snapshot, Default::default(), None);
            // Same height as before, should remain the same
            assert_eq!(snapshot.text(), "aaa\n\n\n\n\n\nbbb\nccc\nddd\n\n\n");
        }
    }

    #[gpui::test]
    fn test_blocks_on_wrapped_lines(cx: &mut gpui::TestAppContext) {
        cx.update(init_test);

        let text = "one two three\nfour five six\nseven eight";

        let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));
        let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
        let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
        let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
        let (_, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
        let (_, wraps_snapshot) = cx.update(|cx| {
            WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), Some(px(90.)), cx)
        });
        let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);

        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
        writer.insert(vec![
            BlockProperties {
                style: BlockStyle::Fixed,
                placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(1, 12))),
                render: Arc::new(|_| div().into_any()),
                height: Some(1),
                priority: 0,
            },
            BlockProperties {
                style: BlockStyle::Fixed,
                placement: BlockPlacement::Below(buffer_snapshot.anchor_after(Point::new(1, 1))),
                render: Arc::new(|_| div().into_any()),
                height: Some(1),
                priority: 0,
            },
        ]);

        // Blocks with an 'above' disposition go above their corresponding buffer line.
        // Blocks with a 'below' disposition go below their corresponding buffer line.
        let snapshot = block_map.read(wraps_snapshot, Default::default(), None);
        assert_eq!(
            snapshot.text(),
            "one two \nthree\n\nfour five \nsix\n\nseven \neight"
        );
    }

    #[gpui::test]
    fn test_insert_and_remove_block_anchored_past_soft_wrap(cx: &mut gpui::TestAppContext) {
        cx.update(init_test);

        let text = "one two three\nfour\nfive";

        let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));
        let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
        let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
        let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
        let (_, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
        let (_, wraps_snapshot) = cx.update(|cx| {
            WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), Some(px(90.)), cx)
        });
        let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);

        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
        let block_id = writer.insert(vec![BlockProperties {
            style: BlockStyle::Fixed,
            placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(0, 12))),
            render: Arc::new(|_| div().into_any()),
            height: Some(2),
            priority: 0,
        }])[0];

        let snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
        assert_eq!(snapshot.text(), "\n\none two \nthree\nfour\nfive");

        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
        writer.remove(HashSet::from_iter([block_id]));

        let snapshot = block_map.read(wraps_snapshot, Default::default(), None);
        assert_eq!(snapshot.text(), "one two \nthree\nfour\nfive");
    }

    #[gpui::test]
    fn test_replace_lines(cx: &mut gpui::TestAppContext) {
        cx.update(init_test);

        let text = "line1\nline2\nline3\nline4\nline5";

        let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));
        let buffer_subscription = buffer.update(cx, |buffer, _cx| buffer.subscribe());
        let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
        let (mut inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
        let (mut fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot);
        let tab_size = 1.try_into().unwrap();
        let (mut tab_map, tab_snapshot) = TabMap::new(fold_snapshot, tab_size);
        let (wrap_map, wraps_snapshot) =
            cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
        let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);

        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
        let replace_block_id = writer.insert(vec![BlockProperties {
            style: BlockStyle::Fixed,
            placement: BlockPlacement::Replace(
                buffer_snapshot.anchor_after(Point::new(1, 3))
                    ..=buffer_snapshot.anchor_before(Point::new(3, 1)),
            ),
            height: Some(4),
            render: Arc::new(|_| div().into_any()),
            priority: 0,
        }])[0];

        let blocks_snapshot = block_map.read(wraps_snapshot, Default::default(), None);
        assert_eq!(blocks_snapshot.text(), "line1\n\n\n\n\nline5");

        let buffer_snapshot = buffer.update(cx, |buffer, cx| {
            buffer.edit([(Point::new(2, 0)..Point::new(3, 0), "")], None, cx);
            buffer.snapshot(cx)
        });
        let (inlay_snapshot, inlay_edits) =
            inlay_map.sync(buffer_snapshot, buffer_subscription.consume().into_inner());
        let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
        let (tab_snapshot, tab_edits) = tab_map.sync(fold_snapshot, fold_edits, tab_size);
        let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
            wrap_map.sync(tab_snapshot, tab_edits, cx)
        });
        let blocks_snapshot = block_map.read(wraps_snapshot, wrap_edits, None);
        assert_eq!(blocks_snapshot.text(), "line1\n\n\n\n\nline5");

        let buffer_snapshot = buffer.update(cx, |buffer, cx| {
            buffer.edit(
                [(
                    Point::new(1, 5)..Point::new(1, 5),
                    "\nline 2.1\nline2.2\nline 2.3\nline 2.4",
                )],
                None,
                cx,
            );
            buffer.snapshot(cx)
        });
        let (inlay_snapshot, inlay_edits) = inlay_map.sync(
            buffer_snapshot.clone(),
            buffer_subscription.consume().into_inner(),
        );
        let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
        let (tab_snapshot, tab_edits) = tab_map.sync(fold_snapshot, fold_edits, tab_size);
        let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
            wrap_map.sync(tab_snapshot, tab_edits, cx)
        });
        let blocks_snapshot = block_map.read(wraps_snapshot.clone(), wrap_edits, None);
        assert_eq!(blocks_snapshot.text(), "line1\n\n\n\n\nline5");

        // Blocks inserted right above the start or right below the end of the replaced region are hidden.
        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
        writer.insert(vec![
            BlockProperties {
                style: BlockStyle::Fixed,
                placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(0, 3))),
                height: Some(1),
                render: Arc::new(|_| div().into_any()),
                priority: 0,
            },
            BlockProperties {
                style: BlockStyle::Fixed,
                placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(1, 3))),
                height: Some(1),
                render: Arc::new(|_| div().into_any()),
                priority: 0,
            },
            BlockProperties {
                style: BlockStyle::Fixed,
                placement: BlockPlacement::Below(buffer_snapshot.anchor_after(Point::new(6, 2))),
                height: Some(1),
                render: Arc::new(|_| div().into_any()),
                priority: 0,
            },
        ]);
        let blocks_snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
        assert_eq!(blocks_snapshot.text(), "\nline1\n\n\n\n\nline5");

        // Ensure blocks inserted *inside* replaced region are hidden.
        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
        writer.insert(vec![
            BlockProperties {
                style: BlockStyle::Fixed,
                placement: BlockPlacement::Below(buffer_snapshot.anchor_after(Point::new(1, 3))),
                height: Some(1),
                render: Arc::new(|_| div().into_any()),
                priority: 0,
            },
            BlockProperties {
                style: BlockStyle::Fixed,
                placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(2, 1))),
                height: Some(1),
                render: Arc::new(|_| div().into_any()),
                priority: 0,
            },
            BlockProperties {
                style: BlockStyle::Fixed,
                placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(6, 1))),
                height: Some(1),
                render: Arc::new(|_| div().into_any()),
                priority: 0,
            },
        ]);
        let blocks_snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
        assert_eq!(blocks_snapshot.text(), "\nline1\n\n\n\n\nline5");

        // Removing the replace block shows all the hidden blocks again.
        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
        writer.remove(HashSet::from_iter([replace_block_id]));
        let blocks_snapshot = block_map.read(wraps_snapshot, Default::default(), None);
        assert_eq!(
            blocks_snapshot.text(),
            "\nline1\n\nline2\n\n\nline 2.1\nline2.2\nline 2.3\nline 2.4\n\nline4\n\nline5"
        );
    }

    #[gpui::test]
    fn test_custom_blocks_inside_buffer_folds(cx: &mut gpui::TestAppContext) {
        cx.update(init_test);

        let text = "111\n\n222\n\n333\n\n444\n\n555\n\n666";

        let buffer = cx.update(|cx| {
            let multibuffer = MultiBuffer::build_multi(
                [
                    (text, vec![Point::new(0, 0)..Point::new(0, 3)]),
                    (
                        text,
                        vec![
                            Point::new(2, 0)..Point::new(2, 3),
                            Point::new(4, 0)..Point::new(4, 3),
                            Point::new(6, 0)..Point::new(6, 3),
                        ],
                    ),
                    (
                        text,
                        vec![
                            Point::new(8, 0)..Point::new(8, 3),
                            Point::new(10, 0)..Point::new(10, 3),
                        ],
                    ),
                ],
                cx,
            );
            assert_eq!(multibuffer.read(cx).snapshot(cx).excerpts().count(), 6);
            multibuffer
        });
        let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
        let buffer_ids = buffer_snapshot
            .excerpts()
            .map(|excerpt| excerpt.context.start.buffer_id)
            .dedup()
            .collect::<Vec<_>>();
        assert_eq!(buffer_ids.len(), 3);
        let buffer_id_1 = buffer_ids[0];
        let buffer_id_2 = buffer_ids[1];
        let buffer_id_3 = buffer_ids[2];

        let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
        let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
        let (_, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
        let (_, wrap_snapshot) =
            cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
        let mut block_map = BlockMap::new(wrap_snapshot.clone(), 2, 1);
        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);

        assert_eq!(
            blocks_snapshot.text(),
            "\n\n111\n\n\n222\n\n333\n\n444\n\n\n555\n\n666"
        );
        assert_eq!(
            blocks_snapshot
                .row_infos(BlockRow(0))
                .map(|i| i.buffer_row)
                .collect::<Vec<_>>(),
            vec![
                None,
                None,
                Some(0),
                None,
                None,
                Some(2),
                None,
                Some(4),
                None,
                Some(6),
                None,
                None,
                Some(8),
                None,
                Some(10),
            ]
        );

        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
        let excerpt_blocks_2 = writer.insert(vec![
            BlockProperties {
                style: BlockStyle::Fixed,
                placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(1, 0))),
                height: Some(1),
                render: Arc::new(|_| div().into_any()),
                priority: 0,
            },
            BlockProperties {
                style: BlockStyle::Fixed,
                placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(2, 0))),
                height: Some(1),
                render: Arc::new(|_| div().into_any()),
                priority: 0,
            },
            BlockProperties {
                style: BlockStyle::Fixed,
                placement: BlockPlacement::Below(buffer_snapshot.anchor_after(Point::new(3, 0))),
                height: Some(1),
                render: Arc::new(|_| div().into_any()),
                priority: 0,
            },
        ]);
        let excerpt_blocks_3 = writer.insert(vec![
            BlockProperties {
                style: BlockStyle::Fixed,
                placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(4, 0))),
                height: Some(1),
                render: Arc::new(|_| div().into_any()),
                priority: 0,
            },
            BlockProperties {
                style: BlockStyle::Fixed,
                placement: BlockPlacement::Below(buffer_snapshot.anchor_after(Point::new(5, 0))),
                height: Some(1),
                render: Arc::new(|_| div().into_any()),
                priority: 0,
            },
        ]);

        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);
        assert_eq!(
            blocks_snapshot.text(),
            "\n\n111\n\n\n\n222\n\n\n333\n\n444\n\n\n\n\n555\n\n666\n"
        );
        assert_eq!(
            blocks_snapshot
                .row_infos(BlockRow(0))
                .map(|i| i.buffer_row)
                .collect::<Vec<_>>(),
            vec![
                None,
                None,
                Some(0),
                None,
                None,
                None,
                Some(2),
                None,
                None,
                Some(4),
                None,
                Some(6),
                None,
                None,
                None,
                None,
                Some(8),
                None,
                Some(10),
                None,
            ]
        );

        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
        buffer.read_with(cx, |buffer, cx| {
            writer.fold_buffers([buffer_id_1], buffer, cx);
        });
        let excerpt_blocks_1 = writer.insert(vec![BlockProperties {
            style: BlockStyle::Fixed,
            placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(0, 0))),
            height: Some(1),
            render: Arc::new(|_| div().into_any()),
            priority: 0,
        }]);
        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);
        let blocks = blocks_snapshot
            .blocks_in_range(BlockRow(0)..BlockRow(u32::MAX))
            .collect::<Vec<_>>();
        for (_, block) in &blocks {
            if let BlockId::Custom(custom_block_id) = block.id() {
                assert!(
                    !excerpt_blocks_1.contains(&custom_block_id),
                    "Should have no blocks from the folded buffer"
                );
                assert!(
                    excerpt_blocks_2.contains(&custom_block_id)
                        || excerpt_blocks_3.contains(&custom_block_id),
                    "Should have only blocks from unfolded buffers"
                );
            }
        }
        assert_eq!(
            1,
            blocks
                .iter()
                .filter(|(_, block)| matches!(block, Block::FoldedBuffer { .. }))
                .count(),
            "Should have one folded block, producing a header of the second buffer"
        );
        assert_eq!(
            blocks_snapshot.text(),
            "\n\n\n\n\n222\n\n\n333\n\n444\n\n\n\n\n555\n\n666\n"
        );
        assert_eq!(
            blocks_snapshot
                .row_infos(BlockRow(0))
                .map(|i| i.buffer_row)
                .collect::<Vec<_>>(),
            vec![
                None,
                None,
                None,
                None,
                None,
                Some(2),
                None,
                None,
                Some(4),
                None,
                Some(6),
                None,
                None,
                None,
                None,
                Some(8),
                None,
                Some(10),
                None,
            ]
        );

        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
        buffer.read_with(cx, |buffer, cx| {
            writer.fold_buffers([buffer_id_2], buffer, cx);
        });
        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);
        let blocks = blocks_snapshot
            .blocks_in_range(BlockRow(0)..BlockRow(u32::MAX))
            .collect::<Vec<_>>();
        for (_, block) in &blocks {
            if let BlockId::Custom(custom_block_id) = block.id() {
                assert!(
                    !excerpt_blocks_1.contains(&custom_block_id),
                    "Should have no blocks from the folded buffer_1"
                );
                assert!(
                    !excerpt_blocks_2.contains(&custom_block_id),
                    "Should have no blocks from the folded buffer_2"
                );
                assert!(
                    excerpt_blocks_3.contains(&custom_block_id),
                    "Should have only blocks from unfolded buffers"
                );
            }
        }
        assert_eq!(
            2,
            blocks
                .iter()
                .filter(|(_, block)| matches!(block, Block::FoldedBuffer { .. }))
                .count(),
            "Should have two folded blocks, producing headers"
        );
        assert_eq!(blocks_snapshot.text(), "\n\n\n\n\n\n\n555\n\n666\n");
        assert_eq!(
            blocks_snapshot
                .row_infos(BlockRow(0))
                .map(|i| i.buffer_row)
                .collect::<Vec<_>>(),
            vec![
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                Some(8),
                None,
                Some(10),
                None,
            ]
        );

        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
        buffer.read_with(cx, |buffer, cx| {
            writer.unfold_buffers([buffer_id_1], buffer, cx);
        });
        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);
        let blocks = blocks_snapshot
            .blocks_in_range(BlockRow(0)..BlockRow(u32::MAX))
            .collect::<Vec<_>>();
        for (_, block) in &blocks {
            if let BlockId::Custom(custom_block_id) = block.id() {
                assert!(
                    !excerpt_blocks_2.contains(&custom_block_id),
                    "Should have no blocks from the folded buffer_2"
                );
                assert!(
                    excerpt_blocks_1.contains(&custom_block_id)
                        || excerpt_blocks_3.contains(&custom_block_id),
                    "Should have only blocks from unfolded buffers"
                );
            }
        }
        assert_eq!(
            1,
            blocks
                .iter()
                .filter(|(_, block)| matches!(block, Block::FoldedBuffer { .. }))
                .count(),
            "Should be back to a single folded buffer, producing a header for buffer_2"
        );
        assert_eq!(
            blocks_snapshot.text(),
            "\n\n\n111\n\n\n\n\n\n555\n\n666\n",
            "Should have extra newline for 111 buffer, due to a new block added when it was folded"
        );
        assert_eq!(
            blocks_snapshot
                .row_infos(BlockRow(0))
                .map(|i| i.buffer_row)
                .collect::<Vec<_>>(),
            vec![
                None,
                None,
                None,
                Some(0),
                None,
                None,
                None,
                None,
                None,
                Some(8),
                None,
                Some(10),
                None,
            ]
        );

        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
        buffer.read_with(cx, |buffer, cx| {
            writer.fold_buffers([buffer_id_3], buffer, cx);
        });
        let blocks_snapshot = block_map.read(wrap_snapshot, Patch::default(), None);
        let blocks = blocks_snapshot
            .blocks_in_range(BlockRow(0)..BlockRow(u32::MAX))
            .collect::<Vec<_>>();
        for (_, block) in &blocks {
            if let BlockId::Custom(custom_block_id) = block.id() {
                assert!(
                    excerpt_blocks_1.contains(&custom_block_id),
                    "Should have no blocks from the folded buffer_1"
                );
                assert!(
                    !excerpt_blocks_2.contains(&custom_block_id),
                    "Should have only blocks from unfolded buffers"
                );
                assert!(
                    !excerpt_blocks_3.contains(&custom_block_id),
                    "Should have only blocks from unfolded buffers"
                );
            }
        }

        assert_eq!(
            blocks_snapshot.text(),
            "\n\n\n111\n\n\n\n",
            "Should have a single, first buffer left after folding"
        );
        assert_eq!(
            blocks_snapshot
                .row_infos(BlockRow(0))
                .map(|i| i.buffer_row)
                .collect::<Vec<_>>(),
            vec![None, None, None, Some(0), None, None, None, None,]
        );
    }

    #[gpui::test]
    fn test_basic_buffer_fold(cx: &mut gpui::TestAppContext) {
        cx.update(init_test);

        let text = "111";

        let buffer = cx.update(|cx| {
            MultiBuffer::build_multi([(text, vec![Point::new(0, 0)..Point::new(0, 3)])], cx)
        });
        let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
        let buffer_ids = buffer_snapshot
            .excerpts()
            .map(|excerpt| excerpt.context.start.buffer_id)
            .dedup()
            .collect::<Vec<_>>();
        assert_eq!(buffer_ids.len(), 1);
        let buffer_id = buffer_ids[0];

        let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot);
        let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
        let (_, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
        let (_, wrap_snapshot) =
            cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
        let mut block_map = BlockMap::new(wrap_snapshot.clone(), 2, 1);
        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);

        assert_eq!(blocks_snapshot.text(), "\n\n111");

        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
        buffer.read_with(cx, |buffer, cx| {
            writer.fold_buffers([buffer_id], buffer, cx);
        });
        let blocks_snapshot = block_map.read(wrap_snapshot, Patch::default(), None);
        let blocks = blocks_snapshot
            .blocks_in_range(BlockRow(0)..BlockRow(u32::MAX))
            .collect::<Vec<_>>();
        assert_eq!(
            1,
            blocks
                .iter()
                .filter(|(_, block)| { matches!(block, Block::FoldedBuffer { .. }) })
                .count(),
            "Should have one folded block, producing a header of the second buffer"
        );
        assert_eq!(blocks_snapshot.text(), "\n");
        assert_eq!(
            blocks_snapshot
                .row_infos(BlockRow(0))
                .map(|i| i.buffer_row)
                .collect::<Vec<_>>(),
            vec![None, None],
            "When fully folded, should be no buffer rows"
        );
    }

    #[gpui::test(iterations = 60)]
    fn test_random_blocks(cx: &mut gpui::TestAppContext, mut rng: StdRng) {
        cx.update(init_test);

        let operations = env::var("OPERATIONS")
            .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
            .unwrap_or(10);

        let wrap_width = if rng.random_bool(0.2) {
            None
        } else {
            Some(px(rng.random_range(0.0..=100.0)))
        };
        let tab_size = 1.try_into().unwrap();
        let font_size = px(14.0);
        let buffer_start_header_height = rng.random_range(1..=5);
        let excerpt_header_height = rng.random_range(1..=5);

        log::info!("Wrap width: {:?}", wrap_width);
        log::info!("Excerpt Header Height: {:?}", excerpt_header_height);
        let is_singleton = rng.random();
        let buffer = if is_singleton {
            let len = rng.random_range(0..10);
            let text = RandomCharIter::new(&mut rng).take(len).collect::<String>();
            log::info!("initial singleton buffer text: {:?}", text);
            cx.update(|cx| MultiBuffer::build_simple(&text, cx))
        } else {
            cx.update(|cx| {
                let multibuffer = MultiBuffer::build_random(&mut rng, cx);
                log::info!(
                    "initial multi-buffer text: {:?}",
                    multibuffer.read(cx).read(cx).text()
                );
                multibuffer
            })
        };

        let mut buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
        let (mut inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
        let (mut fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot);
        let (mut tab_map, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
        let font = test_font();
        let (wrap_map, wraps_snapshot) =
            cx.update(|cx| WrapMap::new(tab_snapshot, font, font_size, wrap_width, cx));
        let mut block_map = BlockMap::new(
            wraps_snapshot,
            buffer_start_header_height,
            excerpt_header_height,
        );

        for _ in 0..operations {
            let mut buffer_edits = Vec::new();
            match rng.random_range(0..=100) {
                0..=19 => {
                    let wrap_width = if rng.random_bool(0.2) {
                        None
                    } else {
                        Some(px(rng.random_range(0.0..=100.0)))
                    };
                    log::info!("Setting wrap width to {:?}", wrap_width);
                    wrap_map.update(cx, |map, cx| map.set_wrap_width(wrap_width, cx));
                }
                20..=39 => {
                    let block_count = rng.random_range(1..=5);
                    let block_properties = (0..block_count)
                        .map(|_| {
                            let buffer = cx.update(|cx| buffer.read(cx).read(cx).clone());
                            let offset = buffer.clip_offset(
                                rng.random_range(MultiBufferOffset(0)..=buffer.len()),
                                Bias::Left,
                            );
                            let mut min_height = 0;
                            let placement = match rng.random_range(0..3) {
                                0 => {
                                    min_height = 1;
                                    let start = buffer.anchor_after(offset);
                                    let end = buffer.anchor_after(buffer.clip_offset(
                                        rng.random_range(offset..=buffer.len()),
                                        Bias::Left,
                                    ));
                                    BlockPlacement::Replace(start..=end)
                                }
                                1 => BlockPlacement::Above(buffer.anchor_after(offset)),
                                _ => BlockPlacement::Below(buffer.anchor_after(offset)),
                            };

                            let height = rng.random_range(min_height..512);
                            BlockProperties {
                                style: BlockStyle::Fixed,
                                placement,
                                height: Some(height),
                                render: Arc::new(|_| div().into_any()),
                                priority: 0,
                            }
                        })
                        .collect::<Vec<_>>();

                    let (inlay_snapshot, inlay_edits) =
                        inlay_map.sync(buffer_snapshot.clone(), vec![]);
                    let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
                    let (tab_snapshot, tab_edits) =
                        tab_map.sync(fold_snapshot, fold_edits, tab_size);
                    let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
                        wrap_map.sync(tab_snapshot, tab_edits, cx)
                    });
                    let mut block_map = block_map.write(wraps_snapshot, wrap_edits, None);
                    let block_ids =
                        block_map.insert(block_properties.iter().map(|props| BlockProperties {
                            placement: props.placement.clone(),
                            height: props.height,
                            style: props.style,
                            render: Arc::new(|_| div().into_any()),
                            priority: 0,
                        }));

                    for (block_properties, block_id) in block_properties.iter().zip(block_ids) {
                        log::info!(
                            "inserted block {:?} with height {:?} and id {:?}",
                            block_properties
                                .placement
                                .as_ref()
                                .map(|p| p.to_point(&buffer_snapshot)),
                            block_properties.height,
                            block_id
                        );
                    }
                }
                40..=59 if !block_map.custom_blocks.is_empty() => {
                    let block_count = rng.random_range(1..=4.min(block_map.custom_blocks.len()));
                    let block_ids_to_remove = block_map
                        .custom_blocks
                        .choose_multiple(&mut rng, block_count)
                        .map(|block| block.id)
                        .collect::<HashSet<_>>();

                    let (inlay_snapshot, inlay_edits) =
                        inlay_map.sync(buffer_snapshot.clone(), vec![]);
                    let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
                    let (tab_snapshot, tab_edits) =
                        tab_map.sync(fold_snapshot, fold_edits, tab_size);
                    let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
                        wrap_map.sync(tab_snapshot, tab_edits, cx)
                    });
                    let mut block_map = block_map.write(wraps_snapshot, wrap_edits, None);
                    log::info!(
                        "removing {} blocks: {:?}",
                        block_ids_to_remove.len(),
                        block_ids_to_remove
                    );
                    block_map.remove(block_ids_to_remove);
                }
                60..=79 => {
                    if buffer.read_with(cx, |buffer, _| buffer.is_singleton()) {
                        log::info!("Noop fold/unfold operation on a singleton buffer");
                        continue;
                    }
                    let (inlay_snapshot, inlay_edits) =
                        inlay_map.sync(buffer_snapshot.clone(), vec![]);
                    let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
                    let (tab_snapshot, tab_edits) =
                        tab_map.sync(fold_snapshot, fold_edits, tab_size);
                    let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
                        wrap_map.sync(tab_snapshot, tab_edits, cx)
                    });
                    let mut block_map = block_map.write(wraps_snapshot, wrap_edits, None);
                    let folded_buffers: Vec<_> =
                        block_map.block_map.folded_buffers.iter().cloned().collect();
                    let mut unfolded_buffers = buffer_snapshot
                        .buffer_ids_for_range(Anchor::Min..Anchor::Max)
                        .collect::<Vec<_>>();
                    unfolded_buffers.dedup();
                    log::debug!("All buffers {unfolded_buffers:?}");
                    log::debug!("Folded buffers {folded_buffers:?}");
                    unfolded_buffers.retain(|buffer_id| {
                        !block_map.block_map.folded_buffers.contains(buffer_id)
                    });
                    let mut folded_count = folded_buffers.len();
                    let mut unfolded_count = unfolded_buffers.len();

                    let fold = !unfolded_buffers.is_empty() && rng.random_bool(0.5);
                    let unfold = !folded_buffers.is_empty() && rng.random_bool(0.5);
                    if !fold && !unfold {
                        log::info!(
                            "Noop fold/unfold operation. Unfolded buffers: {unfolded_count}, folded buffers: {folded_count}"
                        );
                        continue;
                    }

                    buffer.update(cx, |buffer, cx| {
                        if fold {
                            let buffer_to_fold =
                                unfolded_buffers[rng.random_range(0..unfolded_buffers.len())];
                            log::info!("Folding {buffer_to_fold:?}");
                            let related_excerpts = buffer_snapshot
                                .excerpts()
                                .filter_map(|excerpt| {
                                    if excerpt.context.start.buffer_id == buffer_to_fold {
                                        Some((
                                            excerpt.context.start,
                                            buffer_snapshot
                                                .buffer_for_id(buffer_to_fold)
                                                .unwrap()
                                                .text_for_range(excerpt.context)
                                                .collect::<String>(),
                                        ))
                                    } else {
                                        None
                                    }
                                })
                                .collect::<Vec<_>>();
                            log::info!(
                                "Folding {buffer_to_fold:?}, related excerpts: {related_excerpts:?}"
                            );
                            folded_count += 1;
                            unfolded_count -= 1;
                            block_map.fold_buffers([buffer_to_fold], buffer, cx);
                        }
                        if unfold {
                            let buffer_to_unfold =
                                folded_buffers[rng.random_range(0..folded_buffers.len())];
                            log::info!("Unfolding {buffer_to_unfold:?}");
                            unfolded_count += 1;
                            folded_count -= 1;
                            block_map.unfold_buffers([buffer_to_unfold], buffer, cx);
                        }
                        log::info!(
                            "Unfolded buffers: {unfolded_count}, folded buffers: {folded_count}"
                        );
                    });
                }
                _ => {
                    buffer.update(cx, |buffer, cx| {
                        let mutation_count = rng.random_range(1..=5);
                        let subscription = buffer.subscribe();
                        buffer.randomly_mutate(&mut rng, mutation_count, cx);
                        buffer_snapshot = buffer.snapshot(cx);
                        buffer_edits.extend(subscription.consume());
                        log::info!("buffer text: {:?}", buffer_snapshot.text());
                    });
                }
            }

            let (inlay_snapshot, inlay_edits) =
                inlay_map.sync(buffer_snapshot.clone(), buffer_edits);
            let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
            let (tab_snapshot, tab_edits) = tab_map.sync(fold_snapshot, fold_edits, tab_size);
            let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
                wrap_map.sync(tab_snapshot, tab_edits, cx)
            });
            let blocks_snapshot = block_map.read(wraps_snapshot.clone(), wrap_edits, None);
            assert_eq!(
                blocks_snapshot.transforms.summary().input_rows,
                wraps_snapshot.max_point().row() + RowDelta(1)
            );
            log::info!("wrapped text: {:?}", wraps_snapshot.text());
            log::info!("blocks text: {:?}", blocks_snapshot.text());

            let mut expected_blocks = Vec::new();
            expected_blocks.extend(block_map.custom_blocks.iter().filter_map(|block| {
                Some((
                    block.placement.to_wrap_row(&wraps_snapshot)?,
                    Block::Custom(block.clone()),
                ))
            }));

            let mut inlay_point_cursor = wraps_snapshot.inlay_point_cursor();
            let mut tab_point_cursor = wraps_snapshot.tab_point_cursor();
            let mut fold_point_cursor = wraps_snapshot.fold_point_cursor();
            let mut wrap_point_cursor = wraps_snapshot.wrap_point_cursor();

            // Note that this needs to be synced with the related section in BlockMap::sync
            expected_blocks.extend(block_map.header_and_footer_blocks(
                &buffer_snapshot,
                MultiBufferOffset(0)..,
                |point, bias| {
                    wrap_point_cursor
                        .map(
                            tab_point_cursor.map(
                                fold_point_cursor.map(inlay_point_cursor.map(point, bias), bias),
                            ),
                        )
                        .row()
                },
            ));

            BlockMap::sort_blocks(&mut expected_blocks);

            for (placement, block) in &expected_blocks {
                log::info!(
                    "Block {:?} placement: {:?} Height: {:?}",
                    block.id(),
                    placement,
                    block.height()
                );
            }

            let mut sorted_blocks_iter = expected_blocks.into_iter().peekable();

            let input_buffer_rows = buffer_snapshot
                .row_infos(MultiBufferRow(0))
                .map(|row| row.buffer_row)
                .collect::<Vec<_>>();
            let mut expected_buffer_rows = Vec::new();
            let mut expected_text = String::new();
            let mut expected_block_positions = Vec::new();
            let mut expected_replaced_buffer_rows = HashSet::default();
            let input_text = wraps_snapshot.text();

            // Loop over the input lines, creating (N - 1) empty lines for
            // blocks of height N.
            //
            // It's important to note that output *starts* as one empty line,
            // so we special case row 0 to assume a leading '\n'.
            //
            // Linehood is the birthright of strings.
            let input_text_lines = input_text.split('\n').enumerate().peekable();
            let mut block_row = 0;
            for (wrap_row, input_line) in input_text_lines {
                let wrap_row = WrapRow(wrap_row as u32);
                let multibuffer_row = wraps_snapshot
                    .to_point(WrapPoint::new(wrap_row, 0), Bias::Left)
                    .row;

                // Create empty lines for the above block
                while let Some((placement, block)) = sorted_blocks_iter.peek() {
                    if *placement.start() == wrap_row && block.place_above() {
                        let (_, block) = sorted_blocks_iter.next().unwrap();
                        expected_block_positions.push((block_row, block.id()));
                        if block.height() > 0 {
                            let text = "\n".repeat((block.height() - 1) as usize);
                            if block_row > 0 {
                                expected_text.push('\n')
                            }
                            expected_text.push_str(&text);
                            for _ in 0..block.height() {
                                expected_buffer_rows.push(None);
                            }
                            block_row += block.height();
                        }
                    } else {
                        break;
                    }
                }

                // Skip lines within replace blocks, then create empty lines for the replace block's height
                let mut is_in_replace_block = false;
                if let Some((BlockPlacement::Replace(replace_range), block)) =
                    sorted_blocks_iter.peek()
                    && wrap_row >= *replace_range.start()
                {
                    is_in_replace_block = true;

                    if wrap_row == *replace_range.start() {
                        if matches!(block, Block::FoldedBuffer { .. }) {
                            expected_buffer_rows.push(None);
                        } else {
                            expected_buffer_rows.push(input_buffer_rows[multibuffer_row as usize]);
                        }
                    }

                    if wrap_row == *replace_range.end() {
                        expected_block_positions.push((block_row, block.id()));
                        let text = "\n".repeat((block.height() - 1) as usize);
                        if block_row > 0 {
                            expected_text.push('\n');
                        }
                        expected_text.push_str(&text);

                        for _ in 1..block.height() {
                            expected_buffer_rows.push(None);
                        }
                        block_row += block.height();

                        sorted_blocks_iter.next();
                    }
                }

                if is_in_replace_block {
                    expected_replaced_buffer_rows.insert(MultiBufferRow(multibuffer_row));
                } else {
                    let buffer_row = input_buffer_rows[multibuffer_row as usize];
                    let soft_wrapped = wraps_snapshot
                        .to_tab_point(WrapPoint::new(wrap_row, 0))
                        .column()
                        > 0;
                    expected_buffer_rows.push(if soft_wrapped { None } else { buffer_row });
                    if block_row > 0 {
                        expected_text.push('\n');
                    }
                    expected_text.push_str(input_line);
                    block_row += 1;
                }

                while let Some((placement, block)) = sorted_blocks_iter.peek() {
                    if *placement.end() == wrap_row && block.place_below() {
                        let (_, block) = sorted_blocks_iter.next().unwrap();
                        expected_block_positions.push((block_row, block.id()));
                        if block.height() > 0 {
                            let text = "\n".repeat((block.height() - 1) as usize);
                            if block_row > 0 {
                                expected_text.push('\n')
                            }
                            expected_text.push_str(&text);
                            for _ in 0..block.height() {
                                expected_buffer_rows.push(None);
                            }
                            block_row += block.height();
                        }
                    } else {
                        break;
                    }
                }
            }

            let expected_lines = expected_text.split('\n').collect::<Vec<_>>();
            let expected_row_count = expected_lines.len();
            log::info!("expected text: {expected_text:?}");

            assert_eq!(
                blocks_snapshot.max_point().row + 1,
                expected_row_count as u32,
                "actual row count != expected row count",
            );
            assert_eq!(
                blocks_snapshot.text(),
                expected_text,
                "actual text != expected text",
            );

            for start_row in 0..expected_row_count {
                let end_row = rng.random_range(start_row + 1..=expected_row_count);
                let mut expected_text = expected_lines[start_row..end_row].join("\n");
                if end_row < expected_row_count {
                    expected_text.push('\n');
                }

                let actual_text = blocks_snapshot
                    .chunks(
                        BlockRow(start_row as u32)..BlockRow(end_row as u32),
                        LanguageAwareStyling {
                            tree_sitter: false,
                            diagnostics: false,
                        },
                        false,
                        Highlights::default(),
                    )
                    .map(|chunk| chunk.text)
                    .collect::<String>();
                assert_eq!(
                    actual_text,
                    expected_text,
                    "incorrect text starting row row range {:?}",
                    start_row..end_row
                );
                assert_eq!(
                    blocks_snapshot
                        .row_infos(BlockRow(start_row as u32))
                        .map(|row_info| row_info.buffer_row)
                        .collect::<Vec<_>>(),
                    &expected_buffer_rows[start_row..],
                    "incorrect buffer_rows starting at row {:?}",
                    start_row
                );
            }

            assert_eq!(
                blocks_snapshot
                    .blocks_in_range(BlockRow(0)..BlockRow(expected_row_count as u32))
                    .map(|(row, block)| (row.0, block.id()))
                    .collect::<Vec<_>>(),
                expected_block_positions,
                "invalid blocks_in_range({:?})",
                0..expected_row_count
            );

            for (_, expected_block) in
                blocks_snapshot.blocks_in_range(BlockRow(0)..BlockRow(expected_row_count as u32))
            {
                let actual_block = blocks_snapshot.block_for_id(expected_block.id());
                assert_eq!(
                    actual_block.map(|block| block.id()),
                    Some(expected_block.id())
                );
            }

            for (block_row, block_id) in expected_block_positions {
                if let BlockId::Custom(block_id) = block_id {
                    assert_eq!(
                        blocks_snapshot.row_for_block(block_id),
                        Some(BlockRow(block_row))
                    );
                }
            }

            let mut expected_longest_rows = Vec::new();
            let mut longest_line_len = -1_isize;
            for (row, line) in expected_lines.iter().enumerate() {
                let row = row as u32;

                assert_eq!(
                    blocks_snapshot.line_len(BlockRow(row)),
                    line.len() as u32,
                    "invalid line len for row {}",
                    row
                );

                let line_char_count = line.chars().count() as isize;
                match line_char_count.cmp(&longest_line_len) {
                    Ordering::Less => {}
                    Ordering::Equal => expected_longest_rows.push(row),
                    Ordering::Greater => {
                        longest_line_len = line_char_count;
                        expected_longest_rows.clear();
                        expected_longest_rows.push(row);
                    }
                }
            }

            let longest_row = blocks_snapshot.longest_row();
            assert!(
                expected_longest_rows.contains(&longest_row.0),
                "incorrect longest row {}. expected {:?} with length {}",
                longest_row.0,
                expected_longest_rows,
                longest_line_len,
            );

            for _ in 0..10 {
                let end_row = rng.random_range(1..=expected_lines.len());
                let start_row = rng.random_range(0..end_row);

                let mut expected_longest_rows_in_range = vec![];
                let mut longest_line_len_in_range = 0;

                for (row, line) in (start_row as u32..).zip(&expected_lines[start_row..end_row]) {
                    let line_char_count = line.chars().count() as isize;
                    match line_char_count.cmp(&longest_line_len_in_range) {
                        Ordering::Less => {}
                        Ordering::Equal => expected_longest_rows_in_range.push(row),
                        Ordering::Greater => {
                            longest_line_len_in_range = line_char_count;
                            expected_longest_rows_in_range.clear();
                            expected_longest_rows_in_range.push(row);
                        }
                    }
                }

                let longest_row_in_range = blocks_snapshot
                    .longest_row_in_range(BlockRow(start_row as u32)..BlockRow(end_row as u32));
                assert!(
                    expected_longest_rows_in_range.contains(&longest_row_in_range.0),
                    "incorrect longest row {} in range {:?}. expected {:?} with length {}",
                    longest_row.0,
                    start_row..end_row,
                    expected_longest_rows_in_range,
                    longest_line_len_in_range,
                );
            }

            // Ensure that conversion between block points and wrap points is stable.
            for row in 0..=blocks_snapshot.wrap_snapshot.max_point().row().0 {
                let wrap_point = WrapPoint::new(WrapRow(row), 0);
                let block_point = blocks_snapshot.to_block_point(wrap_point);
                let left_wrap_point = blocks_snapshot.to_wrap_point(block_point, Bias::Left);
                let right_wrap_point = blocks_snapshot.to_wrap_point(block_point, Bias::Right);
                assert_eq!(blocks_snapshot.to_block_point(left_wrap_point), block_point);
                assert_eq!(
                    blocks_snapshot.to_block_point(right_wrap_point),
                    block_point
                );
            }

            let mut block_point = BlockPoint::new(BlockRow(0), 0);
            for c in expected_text.chars() {
                let left_point = blocks_snapshot.clip_point(block_point, Bias::Left);
                let left_buffer_point = blocks_snapshot.to_point(left_point, Bias::Left);
                assert_eq!(
                    blocks_snapshot
                        .to_block_point(blocks_snapshot.to_wrap_point(left_point, Bias::Left)),
                    left_point,
                    "block point: {:?}, wrap point: {:?}",
                    block_point,
                    blocks_snapshot.to_wrap_point(left_point, Bias::Left)
                );
                assert_eq!(
                    left_buffer_point,
                    buffer_snapshot.clip_point(left_buffer_point, Bias::Right),
                    "{:?} is not valid in buffer coordinates",
                    left_point
                );

                let right_point = blocks_snapshot.clip_point(block_point, Bias::Right);
                let right_buffer_point = blocks_snapshot.to_point(right_point, Bias::Right);
                assert_eq!(
                    blocks_snapshot
                        .to_block_point(blocks_snapshot.to_wrap_point(right_point, Bias::Right)),
                    right_point,
                    "block point: {:?}, wrap point: {:?}",
                    block_point,
                    blocks_snapshot.to_wrap_point(right_point, Bias::Right)
                );
                assert_eq!(
                    right_buffer_point,
                    buffer_snapshot.clip_point(right_buffer_point, Bias::Left),
                    "{:?} is not valid in buffer coordinates",
                    right_point
                );

                if c == '\n' {
                    block_point.0 += Point::new(1, 0);
                } else {
                    block_point.column += c.len_utf8() as u32;
                }
            }

            for buffer_row in 0..=buffer_snapshot.max_point().row {
                let buffer_row = MultiBufferRow(buffer_row);
                assert_eq!(
                    blocks_snapshot.is_line_replaced(buffer_row),
                    expected_replaced_buffer_rows.contains(&buffer_row),
                    "incorrect is_line_replaced({buffer_row:?}), expected replaced rows: {expected_replaced_buffer_rows:?}",
                );
            }
        }
    }

    /// Deterministic demonstration of the root cause behind ZED-7G6's crash
    /// family: multibuffer anchor comparison is not stable across diff base
    /// text changes, which unsorts the fold map's persistent fold tree.
    ///
    /// Folds inside an expanded deleted hunk anchor at the same buffer
    /// position and are ordered only by their `diff_base_anchor`s into the
    /// diff's base text. When anchor comparison filtered those on
    /// *validity*, a base text change that deleted the region one anchor
    /// pointed into made comparison fall back to the text anchor's bias —
    /// opposite to the answer it gave when the folds were inserted — so the
    /// persistent tree was unsorted without having been touched. Sync then
    /// walked it with forward-only cursors, emitting edits that misdescribed
    /// the change, and the block map kept stale headers for rows that did
    /// change.
    ///
    /// Fixed by filtering diff base anchors on *resolvability* against the
    /// current base buffer instead (monotone: buffer ids never change and
    /// versions only grow), so anchors into deleted base text keep comparing
    /// positionally through their tombstones and the answer never flips.
    #[gpui::test]
    async fn test_folds_stay_sorted_when_diff_base_text_replaced(cx: &mut gpui::TestAppContext) {
        cx.update(init_test);

        let text = "bbb\nccc\nddd\n";
        let base_text = "DEL1\nDEL2\nbbb\nccc\nddd\n";
        let buffer = cx.new(|cx| Buffer::local(text, cx));
        let buffer_text_snapshot = buffer.read_with(cx, |buffer, _| buffer.text_snapshot());
        let diff =
            cx.new(|cx| BufferDiff::new_with_base_text(base_text, &buffer_text_snapshot, cx));

        let multibuffer = cx.new(|cx| {
            let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
            multibuffer.set_all_diff_hunks_expanded(cx);
            multibuffer
        });
        multibuffer.update(cx, |multibuffer, cx| {
            let max_point = buffer.read(cx).max_point();
            multibuffer.set_excerpts_for_buffer(buffer.clone(), [Point::zero()..max_point], 0, cx);
            multibuffer.add_diff(diff.clone(), cx);
        });
        cx.run_until_parked();

        let subscription = multibuffer.update(cx, |multibuffer, _| multibuffer.subscribe());
        let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
        assert_eq!(
            snapshot.text(),
            "DEL1\nDEL2\nbbb\nccc\nddd\n",
            "expected the deleted hunk's rows to be materialized at the top"
        );
        let (mut inlay_map, inlay_snapshot) = InlayMap::new(snapshot.clone());
        let (mut fold_map, _) = FoldMap::new(inlay_snapshot.clone());

        // Two folds inside the deleted hunk share a buffer position and are
        // ordered only by their anchors into the diff's base text: a narrow
        // fold within "DEL1", then a wider fold from "DEL2" into the
        // buffer's own content.
        let (mut writer, ..) = fold_map.write(inlay_snapshot, Vec::new());
        let (fold_snapshot, _) = writer.fold(vec![
            (Point::new(0, 1)..Point::new(1, 0), FoldPlaceholder::test()),
            (Point::new(1, 1)..Point::new(2, 2), FoldPlaceholder::test()),
        ]);
        assert_eq!(
            fold_snapshot.fold_count(),
            2,
            "both folds should anchor inside the expanded deleted hunk"
        );

        // Keep "DEL1" (the first fold's base anchors stay visible) but
        // delete "DEL2" (the second fold's start anchor becomes a tombstone).
        // The folds' relative order must survive this: comparison that
        // filtered out the tombstoned anchor fell back to the text anchor's
        // bias and reversed it.
        let new_base_text = "DEL1\nbbb\nccc\nddd\n";
        diff.update(cx, |diff, cx| {
            diff.set_base_text(Some(new_base_text.into()), buffer_text_snapshot.clone(), cx)
        })
        .await;
        cx.run_until_parked();

        let snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
        let edits = subscription.consume().into_inner();
        let (inlay_snapshot, inlay_edits) = inlay_map.sync(snapshot, edits);
        // `read` checks that the fold tree is still sorted. An unsorted tree
        // makes subsequent syncs emit edits that misdescribe the actual
        // changes, which is what leaves block map headers stale in
        // production.
        fold_map.read(inlay_snapshot, inlay_edits);
    }

    /// Regression fuzz for ZED-7G6 ("buffer snapshot not found for excerpt
    /// boundary"): header blocks cache an `ExcerptBoundaryInfo`, so when a
    /// buffer leaves the multibuffer without the block map re-syncing the
    /// header's rows, the stale block panics at render time. Excerpt removal
    /// is fuzzed together with diffs, folded buffers, text folds, and inlays,
    /// because the crash fires in diff-backed multibuffers like the project
    /// diff.
    ///
    /// Deeper settings have found real bugs; run them locally when touching
    /// this area, e.g. `ITERATIONS=1000 OPERATIONS=40`. Found so far:
    /// `InlayMap::sync` panicking on inlays whose anchors predate a path key
    /// reuse (minimized into `inlay_map`'s
    /// `test_sync_after_path_key_reused_for_different_buffer`), a
    /// `FoldMap` canonical-form violation ("found adjacent isomorphic
    /// transforms", `SEED=612 OPERATIONS=40`), and the fold tree going out of
    /// order (`SEED=144 OPERATIONS=50`): with all diff hunks expanded, fold
    /// anchors carry diff base anchors, and replacing a diff's base text
    /// changes how those anchors compare, unsorting the persistent fold tree
    /// that `FoldMap` seeks through. During the investigation, disabling
    /// the fold and wrap maps' test-only invariants the way production
    /// builds run let the unsorted tree propagate: `FoldMap::sync` panicked
    /// with "cannot seek backward" (`SEED=332 OPERATIONS=60`), matching a
    /// large family of open Sentry crashes with that message, and the wrap
    /// layer emitted edits that no longer covered the rows that actually
    /// changed (`SEED=612 OPERATIONS=50`, caught by
    /// `assert_wrap_edits_cover_changes`), which is the mechanism that
    /// leaves the block map holding stale header blocks. The inlay panic and
    /// the fold tree disorder are fixed by making anchor comparison track
    /// resolution; the canonical-form violation is still unfixed.
    #[gpui::test(iterations = 20)]
    async fn test_random_excerpt_removal_with_diffs(
        cx: &mut gpui::TestAppContext,
        mut rng: StdRng,
    ) {
        cx.update(init_test);

        let operations = env::var("OPERATIONS")
            .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
            .unwrap_or(20);

        let wrap_width = if rng.random_bool(0.2) {
            None
        } else {
            Some(px(rng.random_range(0.0..=100.0)))
        };
        let tab_size = 1.try_into().unwrap();
        let font_size = px(14.0);
        let buffer_start_header_height = rng.random_range(1..=5);
        let excerpt_header_height = rng.random_range(1..=5);
        log::info!("Wrap width: {wrap_width:?}");

        // Half the time, build the multibuffer the way a split diff's left
        // hand side does: excerpts of read-only base text buffers, with
        // inverted diffs pointing at the main buffers.
        let split_style = rng.random_bool(0.5);
        let multibuffer;
        let mut known_buffers;
        let mut diffs = Vec::new();
        if split_style {
            multibuffer = cx.new(|_cx| MultiBuffer::new(Capability::ReadWrite));
            known_buffers = Vec::new();
            for _ in 0..rng.random_range(1..=3) {
                let text = random_buffer_text(&mut rng);
                let main_buffer = cx.new(|cx| Buffer::local(text.clone(), cx));
                let base_text = randomized_text(&text, &mut rng);
                let diff = cx.new(|cx| {
                    BufferDiff::new_with_base_text(
                        &base_text,
                        &main_buffer.read(cx).text_snapshot(),
                        cx,
                    )
                });
                let base_text_buffer =
                    diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());
                multibuffer.update(cx, |multibuffer, cx| {
                    let max_point = base_text_buffer.read(cx).max_point();
                    multibuffer.set_excerpts_for_buffer(
                        base_text_buffer.clone(),
                        [Point::zero()..max_point],
                        0,
                        cx,
                    );
                    multibuffer.add_inverted_diff(diff.clone(), main_buffer.clone(), cx);
                });
                known_buffers.push(base_text_buffer);
                diffs.push((diff, main_buffer));
            }
        } else {
            multibuffer = cx.update(|cx| MultiBuffer::build_random(&mut rng, cx));
            // Diff views like the project diff show all hunks expanded, which
            // materializes deleted rows from base buffers inline.
            if rng.random_bool(0.5) {
                multibuffer.update(cx, |multibuffer, cx| {
                    multibuffer.set_all_diff_hunks_expanded(cx);
                });
            }
            known_buffers = multibuffer.read_with(cx, |multibuffer, _| {
                multibuffer.all_buffers_iter().collect::<Vec<_>>()
            });

            // Attach diffs to a random subset of buffers, with base texts that
            // differ from the buffer text so that hunks exist.
            for buffer in known_buffers.clone() {
                if !rng.random_bool(0.5) {
                    continue;
                }
                let (base_text, buffer_snapshot) = buffer.read_with(cx, |buffer, _| {
                    (
                        randomized_text(&buffer.text(), &mut rng),
                        buffer.text_snapshot(),
                    )
                });
                let diff =
                    cx.new(|cx| BufferDiff::new_with_base_text(&base_text, &buffer_snapshot, cx));
                multibuffer.update(cx, |multibuffer, cx| multibuffer.add_diff(diff.clone(), cx));
                diffs.push((diff, buffer));
            }
        }

        let mut buffer_snapshot =
            multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
        let (mut inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
        let (mut fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot);
        let (mut tab_map, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
        let font = test_font();
        let (wrap_map, wraps_snapshot) =
            cx.update(|cx| WrapMap::new(tab_snapshot, font, font_size, wrap_width, cx));
        let mut previous_wrap_text = wraps_snapshot.text();
        let mut block_map = BlockMap::new(
            wraps_snapshot,
            buffer_start_header_height,
            excerpt_header_height,
        );

        let subscription = multibuffer.update(cx, |multibuffer, _| multibuffer.subscribe());

        let mut next_inlay_id = 0;
        let mut operations_until_sync = 0;
        for _ in 0..operations {
            // Apply several mutations before syncing the display layers, so
            // that edit composition across mutations is exercised the way it is
            // when more than one change lands between frames.
            let sync_now = operations_until_sync == 0;
            if sync_now {
                operations_until_sync = rng.random_range(1..=4);
            }
            operations_until_sync -= 1;

            match rng.random_range(0..100) {
                0..=9 => {
                    let wrap_width = if rng.random_bool(0.2) {
                        None
                    } else {
                        Some(px(rng.random_range(0.0..=100.0)))
                    };
                    log::info!("Setting wrap width to {wrap_width:?}");
                    wrap_map.update(cx, |map, cx| map.set_wrap_width(wrap_width, cx));
                }
                10..=24 => {
                    // Folding reads the block map, so bring the display layers
                    // up to date with any mutations batched since the last sync.
                    buffer_snapshot =
                        multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
                    let pending_edits = subscription.consume().into_inner();
                    let (inlay_snapshot, inlay_edits) =
                        inlay_map.sync(buffer_snapshot.clone(), pending_edits);
                    let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
                    let (tab_snapshot, tab_edits) =
                        tab_map.sync(fold_snapshot, fold_edits, tab_size);
                    let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
                        wrap_map.sync(tab_snapshot, tab_edits, cx)
                    });
                    assert_wrap_edits_cover_changes(
                        &mut previous_wrap_text,
                        &wraps_snapshot,
                        &wrap_edits,
                    );
                    let mut writer = block_map.write(wraps_snapshot, wrap_edits, None);
                    let folded_buffers = writer
                        .block_map
                        .folded_buffers
                        .iter()
                        .cloned()
                        .collect::<Vec<_>>();
                    let mut unfolded_buffers = buffer_snapshot
                        .buffer_ids_for_range(Anchor::Min..Anchor::Max)
                        .collect::<Vec<_>>();
                    unfolded_buffers.dedup();
                    unfolded_buffers.retain(|buffer_id| !folded_buffers.contains(buffer_id));

                    multibuffer.read_with(cx, |multibuffer, cx| {
                        if !unfolded_buffers.is_empty()
                            && (folded_buffers.is_empty() || rng.random_bool(0.5))
                        {
                            let buffer_to_fold = *unfolded_buffers.choose(&mut rng).unwrap();
                            log::info!("Folding {buffer_to_fold:?}");
                            writer.fold_buffers([buffer_to_fold], multibuffer, cx);
                        } else if !folded_buffers.is_empty() {
                            let buffer_to_unfold = *folded_buffers.choose(&mut rng).unwrap();
                            log::info!("Unfolding {buffer_to_unfold:?}");
                            writer.unfold_buffers([buffer_to_unfold], multibuffer, cx);
                        }
                    });
                }
                // Remove all excerpts for a buffer, as happens when a file
                // leaves the project diff.
                25..=44 => {
                    let buffer_ids = multibuffer.read_with(cx, |multibuffer, cx| {
                        multibuffer
                            .snapshot(cx)
                            .all_buffer_ids()
                            .collect::<Vec<_>>()
                    });
                    if buffer_ids.is_empty() {
                        continue;
                    }
                    let buffer_id = *buffer_ids.choose(&mut rng).unwrap();
                    log::info!("Removing excerpts for buffer {buffer_id:?}");
                    multibuffer.update(cx, |multibuffer, cx| {
                        multibuffer.remove_excerpts_for_buffer(buffer_id, cx);
                    });
                }
                // Add excerpts for a buffer that currently has none, as
                // happens when a file (re-)enters the project diff.
                45..=59 => {
                    let present = multibuffer.read_with(cx, |multibuffer, cx| {
                        multibuffer
                            .snapshot(cx)
                            .all_buffer_ids()
                            .collect::<Vec<_>>()
                    });
                    let absent = known_buffers
                        .iter()
                        .filter(|buffer| {
                            !present.contains(&buffer.read_with(cx, |buffer, _| buffer.remote_id()))
                        })
                        .cloned()
                        .collect::<Vec<_>>();

                    let buffer = if absent.is_empty() || rng.random_bool(0.3) {
                        let text = random_buffer_text(&mut rng);
                        log::info!("Creating new buffer with text: {text:?}");
                        let buffer = cx.new(|cx| Buffer::local(text, cx));
                        known_buffers.push(buffer.clone());
                        buffer
                    } else {
                        absent.choose(&mut rng).unwrap().clone()
                    };

                    let max_row =
                        buffer.read_with(cx, |buffer, _| buffer.snapshot().max_point().row);
                    let ranges = (0..rng.random_range(1..=3))
                        .map(|_| {
                            let start_row = rng.random_range(0..=max_row);
                            let end_row = rng.random_range(start_row..=max_row);
                            Point::new(start_row, 0)..Point::new(end_row, 0)
                        })
                        .collect::<Vec<_>>();
                    log::info!("Setting excerpts {ranges:?}");
                    multibuffer.update(cx, |multibuffer, cx| {
                        multibuffer.set_excerpts_for_buffer(buffer.clone(), ranges, 0, cx);
                        // Re-attach the buffer's diff if it has one, like the
                        // project diff does when a file re-enters.
                        if let Some((diff, _)) =
                            diffs.iter().find(|(_, candidate)| *candidate == buffer)
                        {
                            multibuffer.add_diff(diff.clone(), cx);
                        }
                    });
                }
                // Change a diff's base text, as happens when the diff base
                // changes or HEAD advances.
                60..=69 if !diffs.is_empty() => {
                    let (diff, buffer) = diffs.choose(&mut rng).unwrap().clone();
                    let new_base_text = diff.read_with(cx, |diff, cx| {
                        randomized_text(&diff.base_text_string(cx).unwrap_or_default(), &mut rng)
                    });
                    let buffer_text_snapshot =
                        buffer.read_with(cx, |buffer, _| buffer.text_snapshot());
                    log::info!("Setting diff base text to {new_base_text:?}");
                    diff.update(cx, |diff, cx| {
                        diff.set_base_text(Some(new_base_text.into()), buffer_text_snapshot, cx)
                    })
                    .await;
                    cx.run_until_parked();
                }
                // Fold or unfold random text ranges, so that fold edits are
                // propagated through the tab and wrap layers alongside the
                // multibuffer mutations. Mutating the inlay and fold maps
                // requires them to be current, as `DisplayMap` keeps them, so
                // sync the pending mutations through first.
                70..=81 => {
                    buffer_snapshot =
                        multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
                    let pending_edits = subscription.consume().into_inner();
                    let (inlay_snapshot, inlay_edits) =
                        inlay_map.sync(buffer_snapshot.clone(), pending_edits);
                    let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
                    let (tab_snapshot, tab_edits) =
                        tab_map.sync(fold_snapshot, fold_edits, tab_size);
                    let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
                        wrap_map.sync(tab_snapshot, tab_edits, cx)
                    });
                    assert_wrap_edits_cover_changes(
                        &mut previous_wrap_text,
                        &wraps_snapshot,
                        &wrap_edits,
                    );
                    block_map.read(wraps_snapshot, wrap_edits, None);

                    if rng.random_bool(0.5) {
                        for (fold_snapshot, fold_edits) in fold_map.randomly_mutate(&mut rng) {
                            let (tab_snapshot, tab_edits) =
                                tab_map.sync(fold_snapshot, fold_edits, tab_size);
                            let (wraps_snapshot, wrap_edits) = wrap_map
                                .update(cx, |wrap_map, cx| {
                                    wrap_map.sync(tab_snapshot, tab_edits, cx)
                                });
                            assert_wrap_edits_cover_changes(
                                &mut previous_wrap_text,
                                &wraps_snapshot,
                                &wrap_edits,
                            );
                            block_map.read(wraps_snapshot, wrap_edits, None);
                        }
                    } else {
                        let (inlay_snapshot, inlay_edits) =
                            inlay_map.randomly_mutate(&mut next_inlay_id, &mut rng);
                        let (fold_snapshot, fold_edits) =
                            fold_map.read(inlay_snapshot, inlay_edits);
                        let (tab_snapshot, tab_edits) =
                            tab_map.sync(fold_snapshot, fold_edits, tab_size);
                        let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
                            wrap_map.sync(tab_snapshot, tab_edits, cx)
                        });
                        assert_wrap_edits_cover_changes(
                            &mut previous_wrap_text,
                            &wraps_snapshot,
                            &wrap_edits,
                        );
                        block_map.read(wraps_snapshot, wrap_edits, None);
                    }
                }
                // Update a path's excerpts through `update_path_excerpts`,
                // sometimes reusing a path key for a different buffer, as
                // split diffs do when a file's diff base buffer is recreated.
                82..=89 => {
                    let paths = multibuffer.read_with(cx, |multibuffer, cx| {
                        let snapshot = multibuffer.snapshot(cx);
                        snapshot
                            .all_buffer_ids()
                            .filter_map(|id| snapshot.path_for_buffer(id).cloned())
                            .collect::<Vec<_>>()
                    });
                    if paths.is_empty() || known_buffers.is_empty() {
                        continue;
                    }
                    let path = paths.choose(&mut rng).unwrap().clone();

                    let buffer = if rng.random_bool(0.5) {
                        let text = random_buffer_text(&mut rng);
                        let buffer = cx.new(|cx| Buffer::local(text, cx));
                        known_buffers.push(buffer.clone());
                        buffer
                    } else {
                        known_buffers.choose(&mut rng).unwrap().clone()
                    };
                    let max_row =
                        buffer.read_with(cx, |buffer, _| buffer.snapshot().max_point().row);
                    let ranges = (0..rng.random_range(0..=3))
                        .map(|_| {
                            let start_row = rng.random_range(0..=max_row);
                            let end_row = rng.random_range(start_row..=max_row);
                            Point::new(start_row, 0)..Point::new(end_row, 0)
                        })
                        .collect::<Vec<_>>();
                    log::info!("Setting excerpts for path {path:?} with ranges {ranges:?}");
                    multibuffer.update(cx, |multibuffer, cx| {
                        multibuffer.set_excerpts_for_path(path, buffer, ranges, 0, cx);
                    });
                }
                _ => {
                    // Base text buffers are read-only in production, so only
                    // edit buffers that are actually editable.
                    let buffers = multibuffer.read_with(cx, |multibuffer, cx| {
                        multibuffer
                            .all_buffers_iter()
                            .filter(|buffer| !buffer.read(cx).read_only())
                            .collect::<Vec<_>>()
                    });
                    let editable = buffers
                        .into_iter()
                        .chain(diffs.iter().map(|(_, buffer)| buffer.clone()))
                        .collect::<Vec<_>>();
                    let Some(buffer) = editable.choose(&mut rng).cloned() else {
                        continue;
                    };
                    buffer.update(cx, |buffer, cx| {
                        let edit_count = rng.random_range(1..=3);
                        buffer.randomly_edit(&mut rng, edit_count, cx);
                    });
                    // Recalculate any diff for the edited buffer, mirroring
                    // the recalculation that follows a buffer edit.
                    let snapshot = buffer.read_with(cx, |buffer, _| buffer.text_snapshot());
                    for (diff, diff_buffer) in &diffs {
                        if *diff_buffer == buffer {
                            diff.update(cx, |diff, cx| diff.recalculate_diff_sync(&snapshot, cx));
                        }
                    }
                }
            }

            if !sync_now {
                continue;
            }

            buffer_snapshot = multibuffer.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx));
            let buffer_edits = subscription.consume().into_inner();
            let (inlay_snapshot, inlay_edits) =
                inlay_map.sync(buffer_snapshot.clone(), buffer_edits);
            let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
            let (tab_snapshot, tab_edits) = tab_map.sync(fold_snapshot, fold_edits, tab_size);
            let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
                wrap_map.sync(tab_snapshot, tab_edits, cx)
            });
            assert_wrap_edits_cover_changes(&mut previous_wrap_text, &wraps_snapshot, &wrap_edits);
            let blocks_snapshot = block_map.read(wraps_snapshot.clone(), wrap_edits, None);
            log::info!("blocks text: {:?}", blocks_snapshot.text());
            assert_excerpts_resolve(&buffer_snapshot);

            let max_row = blocks_snapshot.max_point().row;
            for (row, block) in blocks_snapshot.blocks_in_range(BlockRow(0)..BlockRow(max_row + 1))
            {
                let excerpt = match block {
                    Block::BufferHeader { excerpt, .. }
                    | Block::ExcerptBoundary { excerpt, .. } => excerpt,
                    Block::FoldedBuffer { first_excerpt, .. } => first_excerpt,
                    _ => continue,
                };
                assert!(
                    buffer_snapshot.buffer_for_id(excerpt.buffer_id()).is_some(),
                    "stale header block {:?} at {row:?} references buffer {:?}, \
                     which is no longer in the multibuffer",
                    block.id(),
                    excerpt.buffer_id(),
                );
            }
        }
    }

    #[gpui::test]
    fn test_remove_intersecting_replace_blocks_edge_case(cx: &mut gpui::TestAppContext) {
        cx.update(init_test);

        let text = "abc\ndef\nghi\njkl\nmno";
        let buffer = cx.update(|cx| MultiBuffer::build_simple(text, cx));
        let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
        let (_inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
        let (_fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot);
        let (_tab_map, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
        let (_wrap_map, wraps_snapshot) =
            cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
        let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);

        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
        let _block_id = writer.insert(vec![BlockProperties {
            style: BlockStyle::Fixed,
            placement: BlockPlacement::Above(buffer_snapshot.anchor_after(Point::new(1, 0))),
            height: Some(1),
            render: Arc::new(|_| div().into_any()),
            priority: 0,
        }])[0];

        let blocks_snapshot = block_map.read(wraps_snapshot.clone(), Default::default(), None);
        assert_eq!(blocks_snapshot.text(), "abc\n\ndef\nghi\njkl\nmno");

        let mut writer = block_map.write(wraps_snapshot.clone(), Default::default(), None);
        writer.remove_intersecting_replace_blocks(
            [buffer_snapshot
                .anchor_after(Point::new(1, 0))
                .to_offset(&buffer_snapshot)
                ..buffer_snapshot
                    .anchor_after(Point::new(1, 0))
                    .to_offset(&buffer_snapshot)],
            false,
        );
        let blocks_snapshot = block_map.read(wraps_snapshot, Default::default(), None);
        assert_eq!(blocks_snapshot.text(), "abc\n\ndef\nghi\njkl\nmno");
    }

    #[gpui::test]
    fn test_folded_buffer_with_near_blocks(cx: &mut gpui::TestAppContext) {
        cx.update(init_test);

        let text = "line 1\nline 2\nline 3";
        let buffer = cx.update(|cx| {
            MultiBuffer::build_multi([(text, vec![Point::new(0, 0)..Point::new(2, 6)])], cx)
        });
        let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
        let buffer_ids = buffer_snapshot
            .excerpts()
            .map(|excerpt| excerpt.context.start.buffer_id)
            .dedup()
            .collect::<Vec<_>>();
        assert_eq!(buffer_ids.len(), 1);
        let buffer_id = buffer_ids[0];

        let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
        let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
        let (_, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
        let (_, wrap_snapshot) =
            cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
        let mut block_map = BlockMap::new(wrap_snapshot.clone(), 1, 1);

        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
        writer.insert(vec![BlockProperties {
            style: BlockStyle::Fixed,
            placement: BlockPlacement::Near(buffer_snapshot.anchor_after(Point::new(0, 0))),
            height: Some(1),
            render: Arc::new(|_| div().into_any()),
            priority: 0,
        }]);

        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);
        assert_eq!(blocks_snapshot.text(), "\nline 1\n\nline 2\nline 3");

        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
        buffer.read_with(cx, |buffer, cx| {
            writer.fold_buffers([buffer_id], buffer, cx);
        });

        let blocks_snapshot = block_map.read(wrap_snapshot, Patch::default(), None);
        assert_eq!(blocks_snapshot.text(), "");
    }

    #[gpui::test]
    fn test_folded_buffer_with_near_blocks_on_last_line(cx: &mut gpui::TestAppContext) {
        cx.update(init_test);

        let text = "line 1\nline 2\nline 3\nline 4";
        let buffer = cx.update(|cx| {
            MultiBuffer::build_multi([(text, vec![Point::new(0, 0)..Point::new(3, 6)])], cx)
        });
        let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
        let buffer_ids = buffer_snapshot
            .excerpts()
            .map(|excerpt| excerpt.context.start.buffer_id)
            .dedup()
            .collect::<Vec<_>>();
        assert_eq!(buffer_ids.len(), 1);
        let buffer_id = buffer_ids[0];

        let (_, inlay_snapshot) = InlayMap::new(buffer_snapshot.clone());
        let (_, fold_snapshot) = FoldMap::new(inlay_snapshot);
        let (_, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
        let (_, wrap_snapshot) =
            cx.update(|cx| WrapMap::new(tab_snapshot, font("Helvetica"), px(14.0), None, cx));
        let mut block_map = BlockMap::new(wrap_snapshot.clone(), 1, 1);

        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
        writer.insert(vec![BlockProperties {
            style: BlockStyle::Fixed,
            placement: BlockPlacement::Near(buffer_snapshot.anchor_after(Point::new(3, 6))),
            height: Some(1),
            render: Arc::new(|_| div().into_any()),
            priority: 0,
        }]);

        let blocks_snapshot = block_map.read(wrap_snapshot.clone(), Patch::default(), None);
        assert_eq!(blocks_snapshot.text(), "\nline 1\nline 2\nline 3\nline 4\n");

        let mut writer = block_map.write(wrap_snapshot.clone(), Patch::default(), None);
        buffer.read_with(cx, |buffer, cx| {
            writer.fold_buffers([buffer_id], buffer, cx);
        });

        let blocks_snapshot = block_map.read(wrap_snapshot, Patch::default(), None);
        assert_eq!(blocks_snapshot.text(), "");
    }

    #[gpui::test]
    fn test_companion_spacer_blocks(cx: &mut gpui::TestAppContext) {
        cx.update(init_test);

        let base_text = "aaa\nbbb\nccc\nddd\nddd\nddd\neee\n";
        let main_text = "aaa\nddd\nddd\nddd\nXXX\nYYY\nZZZ\neee\n";

        let rhs_buffer = cx.new(|cx| Buffer::local(main_text, cx));
        let diff = cx.new(|cx| {
            BufferDiff::new_with_base_text(base_text, &rhs_buffer.read(cx).text_snapshot(), cx)
        });
        let lhs_buffer = diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());

        let lhs_multibuffer = cx.new(|cx| {
            let mut mb = MultiBuffer::new(Capability::ReadWrite);
            mb.set_excerpts_for_buffer(
                lhs_buffer.clone(),
                [Point::zero()..lhs_buffer.read(cx).max_point()],
                0,
                cx,
            );
            mb.add_inverted_diff(diff.clone(), rhs_buffer.clone(), cx);
            mb
        });
        let rhs_multibuffer = cx.new(|cx| {
            let mut mb = MultiBuffer::new(Capability::ReadWrite);
            mb.set_excerpts_for_buffer(
                rhs_buffer.clone(),
                [Point::zero()..rhs_buffer.read(cx).max_point()],
                0,
                cx,
            );
            mb.add_diff(diff.clone(), cx);
            mb
        });
        let subscription =
            rhs_multibuffer.update(cx, |rhs_multibuffer, _| rhs_multibuffer.subscribe());

        let lhs_buffer_snapshot = cx.update(|cx| lhs_multibuffer.read(cx).snapshot(cx));
        let (mut _lhs_inlay_map, lhs_inlay_snapshot) = InlayMap::new(lhs_buffer_snapshot);
        let (mut _lhs_fold_map, lhs_fold_snapshot) = FoldMap::new(lhs_inlay_snapshot);
        let (mut _lhs_tab_map, lhs_tab_snapshot) =
            TabMap::new(lhs_fold_snapshot, 4.try_into().unwrap());
        let (_lhs_wrap_map, lhs_wrap_snapshot) =
            cx.update(|cx| WrapMap::new(lhs_tab_snapshot, font("Helvetica"), px(14.0), None, cx));
        let lhs_block_map = BlockMap::new(lhs_wrap_snapshot.clone(), 0, 0);

        let rhs_buffer_snapshot = cx.update(|cx| rhs_multibuffer.read(cx).snapshot(cx));
        let (mut rhs_inlay_map, rhs_inlay_snapshot) = InlayMap::new(rhs_buffer_snapshot);
        let (mut rhs_fold_map, rhs_fold_snapshot) = FoldMap::new(rhs_inlay_snapshot);
        let (mut rhs_tab_map, rhs_tab_snapshot) =
            TabMap::new(rhs_fold_snapshot, 4.try_into().unwrap());
        let (_rhs_wrap_map, rhs_wrap_snapshot) =
            cx.update(|cx| WrapMap::new(rhs_tab_snapshot, font("Helvetica"), px(14.0), None, cx));
        let rhs_block_map = BlockMap::new(rhs_wrap_snapshot.clone(), 0, 0);

        let rhs_entity_id = rhs_multibuffer.entity_id();

        let companion = cx.new(|_| Companion::new(rhs_entity_id));

        let rhs_edits = Patch::new(vec![text::Edit {
            old: WrapRow(0)..rhs_wrap_snapshot.max_point().row(),
            new: WrapRow(0)..rhs_wrap_snapshot.max_point().row(),
        }]);
        let lhs_edits = Patch::new(vec![text::Edit {
            old: WrapRow(0)..lhs_wrap_snapshot.max_point().row(),
            new: WrapRow(0)..lhs_wrap_snapshot.max_point().row(),
        }]);

        let rhs_snapshot = companion.read_with(cx, |companion, _cx| {
            rhs_block_map.read(
                rhs_wrap_snapshot.clone(),
                rhs_edits.clone(),
                Some(CompanionView::new(
                    rhs_entity_id,
                    &lhs_wrap_snapshot,
                    &lhs_edits,
                    companion,
                )),
            )
        });

        let lhs_entity_id = lhs_multibuffer.entity_id();
        let lhs_snapshot = companion.read_with(cx, |companion, _cx| {
            lhs_block_map.read(
                lhs_wrap_snapshot.clone(),
                lhs_edits.clone(),
                Some(CompanionView::new(
                    lhs_entity_id,
                    &rhs_wrap_snapshot,
                    &rhs_edits,
                    companion,
                )),
            )
        });

        // LHS:
        //   aaa
        // - bbb
        // - ccc
        //   ddd
        //   ddd
        //   ddd
        //   <extra line>
        //   <extra line>
        //   <extra line>
        //   *eee
        //
        // RHS:
        //   aaa
        //   <extra line>
        //   <extra line>
        //   ddd
        //   ddd
        //   ddd
        // + XXX
        // + YYY
        // + ZZZ
        //   eee

        assert_eq!(
            rhs_snapshot.snapshot.text(),
            "aaa\n\n\nddd\nddd\nddd\nXXX\nYYY\nZZZ\neee\n",
            "RHS should have 2 spacer lines after 'aaa' to align with LHS's deleted lines"
        );

        assert_eq!(
            lhs_snapshot.snapshot.text(),
            "aaa\nbbb\nccc\nddd\nddd\nddd\n\n\n\neee\n",
            "LHS should have 3 spacer lines in place of RHS's inserted lines"
        );

        // LHS:
        //   aaa
        // - bbb
        // - ccc
        //   ddd
        //   ddd
        //   ddd
        //   <extra line>
        //   <extra line>
        //   <extra line>
        //   eee
        //
        // RHS:
        //   aaa
        //   <extra line>
        //   <extra line>
        //   ddd
        //   foo
        //   foo
        //   foo
        //   ddd
        //   ddd
        // + XXX
        // + YYY
        // + ZZZ
        //   eee

        let rhs_buffer_snapshot = rhs_multibuffer.update(cx, |multibuffer, cx| {
            multibuffer.edit(
                [(Point::new(2, 0)..Point::new(2, 0), "foo\nfoo\nfoo\n")],
                None,
                cx,
            );
            multibuffer.snapshot(cx)
        });

        let (rhs_inlay_snapshot, rhs_inlay_edits) =
            rhs_inlay_map.sync(rhs_buffer_snapshot, subscription.consume().into_inner());
        let (rhs_fold_snapshot, rhs_fold_edits) =
            rhs_fold_map.read(rhs_inlay_snapshot, rhs_inlay_edits);
        let (rhs_tab_snapshot, rhs_tab_edits) =
            rhs_tab_map.sync(rhs_fold_snapshot, rhs_fold_edits, 4.try_into().unwrap());
        let (rhs_wrap_snapshot, rhs_wrap_edits) = _rhs_wrap_map.update(cx, |wrap_map, cx| {
            wrap_map.sync(rhs_tab_snapshot, rhs_tab_edits, cx)
        });

        let rhs_snapshot = companion.read_with(cx, |companion, _cx| {
            rhs_block_map.read(
                rhs_wrap_snapshot.clone(),
                rhs_wrap_edits.clone(),
                Some(CompanionView::new(
                    rhs_entity_id,
                    &lhs_wrap_snapshot,
                    &Default::default(),
                    companion,
                )),
            )
        });

        let lhs_snapshot = companion.read_with(cx, |companion, _cx| {
            lhs_block_map.read(
                lhs_wrap_snapshot.clone(),
                Default::default(),
                Some(CompanionView::new(
                    lhs_entity_id,
                    &rhs_wrap_snapshot,
                    &rhs_wrap_edits,
                    companion,
                )),
            )
        });

        assert_eq!(
            rhs_snapshot.snapshot.text(),
            "aaa\n\n\nddd\nfoo\nfoo\nfoo\nddd\nddd\nXXX\nYYY\nZZZ\neee\n",
            "RHS should have the insertion"
        );

        assert_eq!(
            lhs_snapshot.snapshot.text(),
            "aaa\nbbb\nccc\nddd\n\n\n\nddd\nddd\n\n\n\neee\n",
            "LHS should have 3 more spacer lines to balance the insertion"
        );
    }

    // Regression test for ZED-9V4: `BlockMap::sync` walks the (old) transform
    // tree with a `WrapRow` cursor and used to `cursor.item().unwrap()` for
    // every edit, assuming each edit's `old.start` lands strictly inside the
    // tree. The companion (split-diff) branch of `sync` can compose an edit
    // anchored at the trailing boundary of the old transforms
    // (`old.start == input_rows`), at which point the cursor is past the end of
    // the tree and `item()` is `None`. That used to abort the process.
    #[gpui::test]
    fn test_sync_edit_anchored_at_end_of_transforms(cx: &mut gpui::TestAppContext) {
        cx.update(init_test);

        let buffer = cx.update(|cx| MultiBuffer::build_simple("aaa\nbbb\nccc\n", cx));
        let buffer_snapshot = cx.update(|cx| buffer.read(cx).snapshot(cx));
        let subscription = buffer.update(cx, |buffer, _| buffer.subscribe());

        let (mut inlay_map, inlay_snapshot) = InlayMap::new(buffer_snapshot);
        let (mut fold_map, fold_snapshot) = FoldMap::new(inlay_snapshot);
        let (mut tab_map, tab_snapshot) = TabMap::new(fold_snapshot, 4.try_into().unwrap());
        let (wrap_map, old_wrap_snapshot) =
            cx.update(|cx| WrapMap::new(tab_snapshot, test_font(), px(14.0), None, cx));
        let block_map = BlockMap::new(old_wrap_snapshot.clone(), 0, 0);

        // The tree now spans exactly `old_end` input rows.
        let old_end = old_wrap_snapshot.max_point().row() + RowDelta(1);

        // Grow the buffer so the new snapshot is larger than the old transforms.
        let buffer_snapshot = buffer.update(cx, |buffer, cx| {
            buffer.edit(
                [(Point::new(3, 0)..Point::new(3, 0), "ddd\neee\n")],
                None,
                cx,
            );
            buffer.snapshot(cx)
        });
        let (inlay_snapshot, inlay_edits) =
            inlay_map.sync(buffer_snapshot, subscription.consume().into_inner());
        let (fold_snapshot, fold_edits) = fold_map.read(inlay_snapshot, inlay_edits);
        let (tab_snapshot, tab_edits) =
            tab_map.sync(fold_snapshot, fold_edits, 4.try_into().unwrap());
        let (new_wrap_snapshot, _) = wrap_map.update(cx, |wrap_map, cx| {
            wrap_map.sync(tab_snapshot, tab_edits, cx)
        });
        let new_end = new_wrap_snapshot.max_point().row() + RowDelta(1);

        // An edit anchored exactly at the end of the old transforms, of the shape
        // the companion branch of `sync` can produce.
        let edits = Patch::new(vec![text::Edit {
            old: old_end..old_end,
            new: old_end..new_end,
        }]);

        let snapshot = block_map.read(new_wrap_snapshot, edits, None);
        assert_eq!(snapshot.snapshot.text(), "aaa\nbbb\nccc\nddd\neee\n");
    }

    #[gpui::test]
    fn test_replacement_input_ranges_preserve_partial_tab_rows(cx: &mut gpui::TestAppContext) {
        cx.update(|cx| {
            init_test(cx);
            crate::init(cx);
        });
        let buffer = cx.update(|cx| {
            MultiBuffer::build_simple("one two three\nfour five six\nseven eight", cx)
        });
        let map = cx.new(|cx| {
            DisplayMap::new(
                buffer,
                font("Helvetica"),
                px(14.0),
                Some(px(90.)),
                1,
                1,
                FoldPlaceholder::test(),
                DiagnosticSeverity::Warning,
                cx,
            )
        });
        let mut snapshot = map.update(cx, |map, cx| map.snapshot(cx));
        let wraps = snapshot.wrap_snapshot().clone();
        assert_eq!(
            wraps.text(),
            "one two \nthree\nfour five \nsix\nseven \neight"
        );
        for height in [0, 1, 4] {
            let block = Block::Custom(Arc::new(CustomBlock {
                id: CustomBlockId(0),
                placement: BlockPlacement::Replace(Anchor::Min..=Anchor::Max),
                height: Some(height),
                style: BlockStyle::Fixed,
                render: Arc::new(Mutex::new(Arc::new(|_| div().into_any()))),
                priority: 0,
            }));
            for (hidden, expected) in [
                (0..6, [Some(0..=2), Some(0..=2), Some(0..=2)]),
                (1..5, [None, Some(1..=1), None]),
                (0..5, [Some(0..=1), Some(0..=1), None]),
                (1..6, [None, Some(1..=2), Some(1..=2)]),
                (2..4, [None, Some(1..=1), None]),
                (0..2, [Some(0..=0), None, None]),
                (4..6, [None, None, Some(2..=2)]),
                (0..1, [None, None, None]),
                (5..6, [None, None, None]),
            ] {
                let mut transforms = SumTree::new(());
                push_isomorphic(&mut transforms, RowDelta(hidden.start), &wraps);
                transforms.push(
                    Transform {
                        summary: TransformSummary {
                            input_rows: WrapRow(hidden.end - hidden.start),
                            output_rows: BlockRow(height),
                            ..TransformSummary::default()
                        },
                        block: Some(block.clone()),
                    },
                    (),
                );
                push_isomorphic(&mut transforms, RowDelta(6 - hidden.end), &wraps);
                snapshot.block_snapshot.transforms = transforms;
                assert_eq!(
                    (0..3)
                        .map(|row| snapshot.fully_replaced_tab_rows(row))
                        .collect::<Vec<_>>(),
                    expected,
                    "hidden: {hidden:?}, height: {height}"
                );
                for row in 0..=6 {
                    assert_eq!(
                        snapshot
                            .block_snapshot
                            .replacement_block_input_range(WrapRow(row)),
                        hidden
                            .contains(&row)
                            .then_some(WrapRow(hidden.start)..WrapRow(hidden.end)),
                        "row: {row}, hidden: {hidden:?}, height: {height}"
                    );
                }
            }
        }
    }

    fn init_test(cx: &mut gpui::App) {
        let settings = SettingsStore::test(cx);
        cx.set_global(settings);
        theme_settings::init(theme::LoadThemes::JustBase, cx);
        assets::Assets.load_test_fonts(cx);
    }

    /// Verifies the edit coverage invariant at the wrap boundary: applying the
    /// emitted edits to the previous wrap text must reproduce the new wrap
    /// text exactly. A row that changed without being covered by an edit is
    /// precisely the kind of under-invalidation that leaves the block map
    /// holding stale header blocks (ZED-7G6), because every layer below the
    /// block map propagates its changes only through these edits. Checking at
    /// the wrap boundary catches under-coverage introduced by any layer
    /// beneath it.
    #[track_caller]
    fn assert_wrap_edits_cover_changes(
        previous_wrap_text: &mut String,
        wrap_snapshot: &WrapSnapshot,
        wrap_edits: &WrapPatch,
    ) {
        let new_text = wrap_snapshot.text();
        let old_rows = previous_wrap_text.split('\n').collect::<Vec<_>>();
        let new_rows = new_text.split('\n').collect::<Vec<_>>();

        let mut reconstructed = old_rows.clone();
        for edit in wrap_edits.edits().iter().rev() {
            assert!(
                edit.old.start.0 as usize <= reconstructed.len()
                    && edit.old.end.0 as usize <= old_rows.len(),
                "edit {edit:?} lies outside the previous wrap text ({} rows)",
                old_rows.len(),
            );
            assert!(
                edit.new.end.0 as usize <= new_rows.len(),
                "edit {edit:?} lies outside the new wrap text ({} rows)",
                new_rows.len(),
            );
            reconstructed.splice(
                edit.old.start.0 as usize..edit.old.end.0 as usize,
                new_rows[edit.new.start.0 as usize..edit.new.end.0 as usize]
                    .iter()
                    .copied(),
            );
        }
        assert_eq!(
            reconstructed.join("\n"),
            new_text,
            "wrap edits do not cover all changed rows; edits: {wrap_edits:?}",
        );
        *previous_wrap_text = new_text;
    }

    /// Every excerpt must resolve its buffer, independently of any block: a
    /// snapshot holding an excerpt whose buffer is absent would panic even when
    /// the header rendering it was just computed.
    #[track_caller]
    fn assert_excerpts_resolve(buffer_snapshot: &MultiBufferSnapshot) {
        for excerpt in buffer_snapshot.excerpts() {
            let buffer_id = excerpt.context.start.buffer_id;
            assert!(
                buffer_snapshot.buffer_for_id(buffer_id).is_some(),
                "multibuffer snapshot holds an excerpt for buffer {buffer_id:?}, \
                 which is absent from its buffers",
            );
        }
    }

    /// Empty and single-line buffers are generated often because excerpts
    /// holding no text produce zero-width edits, which `Patch` discards.
    fn random_buffer_text(rng: &mut StdRng) -> String {
        let len = match rng.random_range(0..100) {
            0..=29 => 0,
            30..=59 => rng.random_range(1..4),
            _ => rng.random_range(4..30),
        };
        RandomCharIter::new(rng).take(len).collect()
    }

    fn randomized_text(text: &str, rng: &mut StdRng) -> String {
        let mut chars = text.chars().collect::<Vec<_>>();
        for _ in 0..rng.random_range(1..=3) {
            if chars.is_empty() || rng.random_bool(0.5) {
                let insert_at = rng.random_range(0..=chars.len());
                let insert_len = rng.random_range(1..5);
                for (offset, c) in RandomCharIter::new(&mut *rng).take(insert_len).enumerate() {
                    chars.insert(insert_at + offset, c);
                }
            } else {
                let start = rng.random_range(0..chars.len());
                let end = rng.random_range(start + 1..=chars.len());
                chars.drain(start..end);
            }
        }
        chars.into_iter().collect()
    }

    impl Block {
        fn as_custom(&self) -> Option<&CustomBlock> {
            match self {
                Block::Custom(block) => Some(block),
                _ => None,
            }
        }
    }

    impl BlockSnapshot {
        fn to_point(&self, point: BlockPoint, bias: Bias) -> Point {
            self.wrap_snapshot
                .to_point(self.to_wrap_point(point, bias), bias)
        }
    }
}