logiguard fork v3: full patch set on verified 8c74db0 tree

Includes prior-session patches (carry forward so the app compiles):
  - crates/gpui/build.rs: cross-compile manifest fix
  - crates/gpui/src/platform.rs: PlatformWindow::activate_with_token trait method
  - crates/gpui/src/window.rs: Window::activate_with_token public API
  - crates/gpui_linux/src/linux/wayland/window.rs: WaylandWindow::activate_with_token + activate() keyboard-serial fix

Plus the focus-serial fix:
  - serial.rs: SerialKind::KeyboardEnter
  - client.rs: store wl_keyboard.enter serial; latest_serial_of()

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

crates/sum_tree/Cargo.toml

@@ -0,0 +1,35 @@
+[package]
+name = "sum_tree"
+version = "0.1.0"
+edition.workspace = true
+publish = false
+license = "Apache-2.0"
+description = "A sum tree data structure, a concurrency-friendly B-tree"
+
+[lints]
+workspace = true
+
+[lib]
+path = "src/sum_tree.rs"
+doctest = false
+
+[dependencies]
+heapless.workspace = true
+rayon.workspace = true
+log.workspace = true
+ztracing.workspace = true
+tracing.workspace = true
+proptest = { workspace = true, optional = true }
+
+[dev-dependencies]
+ctor.workspace = true
+rand.workspace = true
+proptest.workspace = true
+zlog.workspace = true
+
+
+[package.metadata.cargo-machete]
+ignored = ["tracing"]
+
+[features]
+test-support = ["proptest"]

crates/sum_tree/LICENSE-APACHE

@@ -0,0 +1 @@
+../../LICENSE-APACHE

crates/sum_tree/src/cursor.rs

@@ -0,0 +1,861 @@
+use super::*;
+use heapless::Vec as ArrayVec;
+use std::{cmp::Ordering, mem, sync::Arc};
+use ztracing::instrument;
+
+#[derive(Clone)]
+struct StackEntry<'a, T: Item, D> {
+    tree: &'a SumTree<T>,
+    index: u32,
+    position: D,
+}
+
+impl<'a, T: Item, D> StackEntry<'a, T, D> {
+    #[inline]
+    fn index(&self) -> usize {
+        self.index as usize
+    }
+}
+
+impl<T: Item + fmt::Debug, D: fmt::Debug> fmt::Debug for StackEntry<'_, T, D> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("StackEntry")
+            .field("index", &self.index)
+            .field("position", &self.position)
+            .finish()
+    }
+}
+
+#[derive(Clone)]
+pub struct Cursor<'a, 'b, T: Item, D> {
+    tree: &'a SumTree<T>,
+    stack: ArrayVec<StackEntry<'a, T, D>, 16, u8>,
+    pub position: D,
+    did_seek: bool,
+    at_end: bool,
+    cx: <T::Summary as Summary>::Context<'b>,
+}
+
+impl<T: Item + fmt::Debug, D: fmt::Debug> fmt::Debug for Cursor<'_, '_, T, D>
+where
+    T::Summary: fmt::Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Cursor")
+            .field("tree", &self.tree)
+            .field("stack", &self.stack)
+            .field("position", &self.position)
+            .field("did_seek", &self.did_seek)
+            .field("at_end", &self.at_end)
+            .finish()
+    }
+}
+
+pub struct Iter<'a, T: Item> {
+    tree: &'a SumTree<T>,
+    stack: ArrayVec<StackEntry<'a, T, ()>, 16, u8>,
+}
+
+impl<'a, 'b, T, D> Cursor<'a, 'b, T, D>
+where
+    T: Item,
+    D: Dimension<'a, T::Summary>,
+{
+    pub fn new(tree: &'a SumTree<T>, cx: <T::Summary as Summary>::Context<'b>) -> Self {
+        Self {
+            tree,
+            stack: ArrayVec::new(),
+            position: D::zero(cx),
+            did_seek: false,
+            at_end: tree.is_empty(),
+            cx,
+        }
+    }
+
+    pub fn reset(&mut self) {
+        self.did_seek = false;
+        self.at_end = self.tree.is_empty();
+        self.stack.truncate(0);
+        self.position = D::zero(self.cx);
+    }
+
+    pub fn start(&self) -> &D {
+        &self.position
+    }
+
+    #[track_caller]
+    pub fn end(&self) -> D {
+        if let Some(item_summary) = self.item_summary() {
+            let mut end = self.start().clone();
+            end.add_summary(item_summary, self.cx);
+            end
+        } else {
+            self.start().clone()
+        }
+    }
+
+    /// Item is None, when the list is empty, or this cursor is at the end of the list.
+    #[track_caller]
+    pub fn item(&self) -> Option<&'a T> {
+        self.assert_did_seek();
+        if let Some(entry) = self.stack.last() {
+            match *entry.tree.0 {
+                Node::Leaf { ref items, .. } => {
+                    if entry.index() == items.len() {
+                        None
+                    } else {
+                        Some(&items[entry.index()])
+                    }
+                }
+                _ => unreachable!(),
+            }
+        } else {
+            None
+        }
+    }
+
+    #[track_caller]
+    pub fn item_summary(&self) -> Option<&'a T::Summary> {
+        self.assert_did_seek();
+        if let Some(entry) = self.stack.last() {
+            match *entry.tree.0 {
+                Node::Leaf {
+                    ref item_summaries, ..
+                } => {
+                    if entry.index() == item_summaries.len() {
+                        None
+                    } else {
+                        Some(&item_summaries[entry.index()])
+                    }
+                }
+                _ => unreachable!(),
+            }
+        } else {
+            None
+        }
+    }
+
+    #[track_caller]
+    pub fn next_item(&self) -> Option<&'a T> {
+        self.assert_did_seek();
+        if let Some(entry) = self.stack.last() {
+            if entry.index() == entry.tree.0.items().len() - 1 {
+                if let Some(next_leaf) = self.next_leaf() {
+                    Some(next_leaf.0.items().first().unwrap())
+                } else {
+                    None
+                }
+            } else {
+                match *entry.tree.0 {
+                    Node::Leaf { ref items, .. } => Some(&items[entry.index() + 1]),
+                    _ => unreachable!(),
+                }
+            }
+        } else if self.at_end {
+            None
+        } else {
+            self.tree.first()
+        }
+    }
+
+    #[track_caller]
+    fn next_leaf(&self) -> Option<&'a SumTree<T>> {
+        for entry in self.stack.iter().rev().skip(1) {
+            if entry.index() < entry.tree.0.child_trees().len() - 1 {
+                match *entry.tree.0 {
+                    Node::Internal {
+                        ref child_trees, ..
+                    } => return Some(child_trees[entry.index() + 1].leftmost_leaf()),
+                    Node::Leaf { .. } => unreachable!(),
+                };
+            }
+        }
+        None
+    }
+
+    #[track_caller]
+    pub fn prev_item(&self) -> Option<&'a T> {
+        self.assert_did_seek();
+        if let Some(entry) = self.stack.last() {
+            if entry.index() == 0 {
+                if let Some(prev_leaf) = self.prev_leaf() {
+                    Some(prev_leaf.0.items().last().unwrap())
+                } else {
+                    None
+                }
+            } else {
+                match *entry.tree.0 {
+                    Node::Leaf { ref items, .. } => Some(&items[entry.index() - 1]),
+                    _ => unreachable!(),
+                }
+            }
+        } else if self.at_end {
+            self.tree.last()
+        } else {
+            None
+        }
+    }
+
+    #[track_caller]
+    fn prev_leaf(&self) -> Option<&'a SumTree<T>> {
+        for entry in self.stack.iter().rev().skip(1) {
+            if entry.index() != 0 {
+                match *entry.tree.0 {
+                    Node::Internal {
+                        ref child_trees, ..
+                    } => return Some(child_trees[entry.index() - 1].rightmost_leaf()),
+                    Node::Leaf { .. } => unreachable!(),
+                };
+            }
+        }
+        None
+    }
+
+    #[track_caller]
+    #[instrument(skip_all)]
+    pub fn prev(&mut self) {
+        self.search_backward(|_| true)
+    }
+
+    #[track_caller]
+    pub fn search_backward<F>(&mut self, mut filter_node: F)
+    where
+        F: FnMut(&T::Summary) -> bool,
+    {
+        if !self.did_seek {
+            self.did_seek = true;
+            self.at_end = true;
+        }
+
+        if self.at_end {
+            self.position = D::zero(self.cx);
+            self.at_end = self.tree.is_empty();
+            if !self.tree.is_empty() {
+                self.stack
+                    .push(StackEntry {
+                        tree: self.tree,
+                        index: self.tree.0.child_summaries().len() as u32,
+                        position: D::from_summary(self.tree.summary(), self.cx),
+                    })
+                    .unwrap_oob();
+            }
+        }
+
+        let mut descending = false;
+        while !self.stack.is_empty() {
+            if let Some(StackEntry { position, .. }) = self.stack.iter().rev().nth(1) {
+                self.position = position.clone();
+            } else {
+                self.position = D::zero(self.cx);
+            }
+
+            let entry = self.stack.last_mut().unwrap();
+            if !descending {
+                if entry.index() == 0 {
+                    self.stack.pop();
+                    continue;
+                } else {
+                    entry.index -= 1;
+                }
+            }
+
+            for summary in &entry.tree.0.child_summaries()[..entry.index()] {
+                self.position.add_summary(summary, self.cx);
+            }
+            entry.position = self.position.clone();
+
+            descending = filter_node(&entry.tree.0.child_summaries()[entry.index()]);
+            match entry.tree.0.as_ref() {
+                Node::Internal { child_trees, .. } => {
+                    if descending {
+                        let tree = &child_trees[entry.index()];
+                        self.stack
+                            .push(StackEntry {
+                                position: D::zero(self.cx),
+                                tree,
+                                index: tree.0.child_summaries().len() as u32 - 1,
+                            })
+                            .unwrap_oob();
+                    }
+                }
+                Node::Leaf { .. } => {
+                    if descending {
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    #[track_caller]
+    pub fn next(&mut self) {
+        self.search_forward(|_| true)
+    }
+
+    #[track_caller]
+    pub fn search_forward<F>(&mut self, mut filter_node: F)
+    where
+        F: FnMut(&T::Summary) -> bool,
+    {
+        let mut descend = false;
+
+        if self.stack.is_empty() {
+            if !self.at_end {
+                self.stack
+                    .push(StackEntry {
+                        tree: self.tree,
+                        index: 0,
+                        position: D::zero(self.cx),
+                    })
+                    .unwrap_oob();
+                descend = true;
+            }
+            self.did_seek = true;
+        }
+
+        while !self.stack.is_empty() {
+            let new_subtree = {
+                let entry = self.stack.last_mut().unwrap();
+                match entry.tree.0.as_ref() {
+                    Node::Internal {
+                        child_trees,
+                        child_summaries,
+                        ..
+                    } => {
+                        if !descend {
+                            entry.index += 1;
+                            entry.position = self.position.clone();
+                        }
+
+                        while entry.index() < child_summaries.len() {
+                            let next_summary = &child_summaries[entry.index()];
+                            if filter_node(next_summary) {
+                                break;
+                            } else {
+                                entry.index += 1;
+                                entry.position.add_summary(next_summary, self.cx);
+                                self.position.add_summary(next_summary, self.cx);
+                            }
+                        }
+
+                        child_trees.get(entry.index())
+                    }
+                    Node::Leaf { item_summaries, .. } => {
+                        if !descend {
+                            let item_summary = &item_summaries[entry.index()];
+                            entry.index += 1;
+                            entry.position.add_summary(item_summary, self.cx);
+                            self.position.add_summary(item_summary, self.cx);
+                        }
+
+                        loop {
+                            if let Some(next_item_summary) = item_summaries.get(entry.index()) {
+                                if filter_node(next_item_summary) {
+                                    return;
+                                } else {
+                                    entry.index += 1;
+                                    entry.position.add_summary(next_item_summary, self.cx);
+                                    self.position.add_summary(next_item_summary, self.cx);
+                                }
+                            } else {
+                                break None;
+                            }
+                        }
+                    }
+                }
+            };
+
+            if let Some(subtree) = new_subtree {
+                descend = true;
+                self.stack
+                    .push(StackEntry {
+                        tree: subtree,
+                        index: 0,
+                        position: self.position.clone(),
+                    })
+                    .unwrap_oob();
+            } else {
+                descend = false;
+                self.stack.pop();
+            }
+        }
+
+        self.at_end = self.stack.is_empty();
+        debug_assert!(self.stack.is_empty() || self.stack.last().unwrap().tree.0.is_leaf());
+    }
+
+    #[track_caller]
+    fn assert_did_seek(&self) {
+        assert!(
+            self.did_seek,
+            "Must call `seek`, `next` or `prev` before calling this method"
+        );
+    }
+
+    pub fn did_seek(&self) -> bool {
+        self.did_seek
+    }
+}
+
+impl<'a, 'b, T, D> Cursor<'a, 'b, T, D>
+where
+    T: Item,
+    D: Dimension<'a, T::Summary>,
+{
+    /// Returns whether we found the item you were seeking for.
+    #[track_caller]
+    #[instrument(skip_all)]
+    pub fn seek<Target>(&mut self, pos: &Target, bias: Bias) -> bool
+    where
+        Target: SeekTarget<'a, T::Summary, D>,
+    {
+        self.reset();
+        self.seek_internal(pos, bias, &mut ())
+    }
+
+    /// Returns whether we found the item you were seeking for.
+    ///
+    /// # Panics
+    ///
+    /// If we did not seek before, use seek instead in that case.
+    #[track_caller]
+    #[instrument(skip_all)]
+    pub fn seek_forward<Target>(&mut self, pos: &Target, bias: Bias) -> bool
+    where
+        Target: SeekTarget<'a, T::Summary, D>,
+    {
+        self.seek_internal(pos, bias, &mut ())
+    }
+
+    /// Advances the cursor and returns traversed items as a tree.
+    #[track_caller]
+    pub fn slice<Target>(&mut self, end: &Target, bias: Bias) -> SumTree<T>
+    where
+        Target: SeekTarget<'a, T::Summary, D>,
+    {
+        let mut slice = SliceSeekAggregate {
+            tree: SumTree::new(self.cx),
+            leaf_items: ArrayVec::new(),
+            leaf_item_summaries: ArrayVec::new(),
+            leaf_summary: <T::Summary as Summary>::zero(self.cx),
+        };
+        self.seek_internal(end, bias, &mut slice);
+        slice.tree
+    }
+
+    #[track_caller]
+    pub fn suffix(&mut self) -> SumTree<T> {
+        self.slice(&End::new(), Bias::Right)
+    }
+
+    #[track_caller]
+    pub fn summary<Target, Output>(&mut self, end: &Target, bias: Bias) -> Output
+    where
+        Target: SeekTarget<'a, T::Summary, D>,
+        Output: Dimension<'a, T::Summary>,
+    {
+        let mut summary = SummarySeekAggregate(Output::zero(self.cx));
+        self.seek_internal(end, bias, &mut summary);
+        summary.0
+    }
+
+    /// Returns whether we found the item you were seeking for.
+    #[track_caller]
+    #[instrument(skip_all)]
+    fn seek_internal(
+        &mut self,
+        target: &dyn SeekTarget<'a, T::Summary, D>,
+        bias: Bias,
+        aggregate: &mut dyn SeekAggregate<'a, T>,
+    ) -> bool {
+        assert!(
+            target.cmp(&self.position, self.cx).is_ge(),
+            "cannot seek backward",
+        );
+
+        if !self.did_seek {
+            self.did_seek = true;
+            self.stack
+                .push(StackEntry {
+                    tree: self.tree,
+                    index: 0,
+                    position: D::zero(self.cx),
+                })
+                .unwrap_oob();
+        }
+
+        let mut ascending = false;
+        'outer: while let Some(entry) = self.stack.last_mut() {
+            match *entry.tree.0 {
+                Node::Internal {
+                    ref child_summaries,
+                    ref child_trees,
+                    ..
+                } => {
+                    if ascending {
+                        entry.index += 1;
+                        entry.position = self.position.clone();
+                    }
+
+                    for (child_tree, child_summary) in child_trees[entry.index()..]
+                        .iter()
+                        .zip(&child_summaries[entry.index()..])
+                    {
+                        let mut child_end = self.position.clone();
+                        child_end.add_summary(child_summary, self.cx);
+
+                        let comparison = target.cmp(&child_end, self.cx);
+                        if comparison == Ordering::Greater
+                            || (comparison == Ordering::Equal && bias == Bias::Right)
+                        {
+                            self.position = child_end;
+                            aggregate.push_tree(child_tree, child_summary, self.cx);
+                            entry.index += 1;
+                            entry.position = self.position.clone();
+                        } else {
+                            self.stack
+                                .push(StackEntry {
+                                    tree: child_tree,
+                                    index: 0,
+                                    position: self.position.clone(),
+                                })
+                                .unwrap_oob();
+                            ascending = false;
+                            continue 'outer;
+                        }
+                    }
+                }
+                Node::Leaf {
+                    ref items,
+                    ref item_summaries,
+                    ..
+                } => {
+                    aggregate.begin_leaf();
+
+                    for (item, item_summary) in items[entry.index()..]
+                        .iter()
+                        .zip(&item_summaries[entry.index()..])
+                    {
+                        let mut child_end = self.position.clone();
+                        child_end.add_summary(item_summary, self.cx);
+
+                        let comparison = target.cmp(&child_end, self.cx);
+                        if comparison == Ordering::Greater
+                            || (comparison == Ordering::Equal && bias == Bias::Right)
+                        {
+                            self.position = child_end;
+                            aggregate.push_item(item, item_summary, self.cx);
+                            entry.index += 1;
+                        } else {
+                            aggregate.end_leaf(self.cx);
+                            break 'outer;
+                        }
+                    }
+
+                    aggregate.end_leaf(self.cx);
+                }
+            }
+
+            self.stack.pop();
+            ascending = true;
+        }
+
+        self.at_end = self.stack.is_empty();
+        debug_assert!(self.stack.is_empty() || self.stack.last().unwrap().tree.0.is_leaf());
+
+        let mut end = self.position.clone();
+        if bias == Bias::Left
+            && let Some(summary) = self.item_summary()
+        {
+            end.add_summary(summary, self.cx);
+        }
+
+        target.cmp(&end, self.cx) == Ordering::Equal
+    }
+}
+
+impl<'a, T: Item> Iter<'a, T> {
+    pub(crate) fn new(tree: &'a SumTree<T>) -> Self {
+        Self {
+            tree,
+            stack: Default::default(),
+        }
+    }
+}
+
+impl<'a, T: Item> Iterator for Iter<'a, T> {
+    type Item = &'a T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let mut descend = false;
+
+        if self.stack.is_empty() {
+            self.stack
+                .push(StackEntry {
+                    tree: self.tree,
+                    index: 0,
+                    position: (),
+                })
+                .unwrap_oob();
+            descend = true;
+        }
+
+        while let Some(entry) = self.stack.last_mut() {
+            let new_subtree = {
+                match entry.tree.0.as_ref() {
+                    Node::Internal { child_trees, .. } => {
+                        if !descend {
+                            entry.index += 1;
+                        }
+                        child_trees.get(entry.index())
+                    }
+                    Node::Leaf { items, .. } => {
+                        if !descend {
+                            entry.index += 1;
+                        }
+
+                        if let Some(next_item) = items.get(entry.index()) {
+                            return Some(next_item);
+                        } else {
+                            None
+                        }
+                    }
+                }
+            };
+
+            if let Some(subtree) = new_subtree {
+                descend = true;
+                self.stack
+                    .push(StackEntry {
+                        tree: subtree,
+                        index: 0,
+                        position: (),
+                    })
+                    .unwrap_oob();
+            } else {
+                descend = false;
+                self.stack.pop();
+            }
+        }
+
+        None
+    }
+
+    fn last(mut self) -> Option<Self::Item> {
+        self.stack.clear();
+        self.tree.rightmost_leaf().last()
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let lower_bound = match self.stack.last() {
+            Some(top) => top.tree.0.child_summaries().len() - top.index as usize,
+            None => self.tree.0.child_summaries().len(),
+        };
+
+        (lower_bound, None)
+    }
+}
+
+impl<'a, 'b, T: Item, D> Iterator for Cursor<'a, 'b, T, D>
+where
+    D: Dimension<'a, T::Summary>,
+{
+    type Item = &'a T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if !self.did_seek {
+            self.next();
+        }
+
+        if let Some(item) = self.item() {
+            self.next();
+            Some(item)
+        } else {
+            None
+        }
+    }
+}
+
+pub struct FilterCursor<'a, 'b, F, T: Item, D> {
+    cursor: Cursor<'a, 'b, T, D>,
+    filter_node: F,
+}
+
+impl<'a, 'b, F, T: Item, D> FilterCursor<'a, 'b, F, T, D>
+where
+    F: FnMut(&T::Summary) -> bool,
+    T: Item,
+    D: Dimension<'a, T::Summary>,
+{
+    pub fn new(
+        tree: &'a SumTree<T>,
+        cx: <T::Summary as Summary>::Context<'b>,
+        filter_node: F,
+    ) -> Self {
+        let cursor = tree.cursor::<D>(cx);
+        Self {
+            cursor,
+            filter_node,
+        }
+    }
+
+    pub fn start(&self) -> &D {
+        self.cursor.start()
+    }
+
+    pub fn end(&self) -> D {
+        self.cursor.end()
+    }
+
+    pub fn item(&self) -> Option<&'a T> {
+        self.cursor.item()
+    }
+
+    pub fn item_summary(&self) -> Option<&'a T::Summary> {
+        self.cursor.item_summary()
+    }
+
+    pub fn next(&mut self) {
+        self.cursor.search_forward(&mut self.filter_node);
+    }
+
+    pub fn prev(&mut self) {
+        self.cursor.search_backward(&mut self.filter_node);
+    }
+}
+
+impl<'a, 'b, F, T: Item, U> Iterator for FilterCursor<'a, 'b, F, T, U>
+where
+    F: FnMut(&T::Summary) -> bool,
+    U: Dimension<'a, T::Summary>,
+{
+    type Item = &'a T;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if !self.cursor.did_seek {
+            self.next();
+        }
+
+        if let Some(item) = self.item() {
+            self.cursor.search_forward(&mut self.filter_node);
+            Some(item)
+        } else {
+            None
+        }
+    }
+}
+
+trait SeekAggregate<'a, T: Item> {
+    fn begin_leaf(&mut self);
+    fn end_leaf(&mut self, cx: <T::Summary as Summary>::Context<'_>);
+    fn push_item(
+        &mut self,
+        item: &'a T,
+        summary: &'a T::Summary,
+        cx: <T::Summary as Summary>::Context<'_>,
+    );
+    fn push_tree(
+        &mut self,
+        tree: &'a SumTree<T>,
+        summary: &'a T::Summary,
+        cx: <T::Summary as Summary>::Context<'_>,
+    );
+}
+
+struct SliceSeekAggregate<T: Item> {
+    tree: SumTree<T>,
+    leaf_items: ArrayVec<T, { 2 * TREE_BASE }, u8>,
+    leaf_item_summaries: ArrayVec<T::Summary, { 2 * TREE_BASE }, u8>,
+    leaf_summary: T::Summary,
+}
+
+struct SummarySeekAggregate<D>(D);
+
+impl<T: Item> SeekAggregate<'_, T> for () {
+    fn begin_leaf(&mut self) {}
+    fn end_leaf(&mut self, _: <T::Summary as Summary>::Context<'_>) {}
+    fn push_item(&mut self, _: &T, _: &T::Summary, _: <T::Summary as Summary>::Context<'_>) {}
+    fn push_tree(
+        &mut self,
+        _: &SumTree<T>,
+        _: &T::Summary,
+        _: <T::Summary as Summary>::Context<'_>,
+    ) {
+    }
+}
+
+impl<T: Item> SeekAggregate<'_, T> for SliceSeekAggregate<T> {
+    fn begin_leaf(&mut self) {}
+    fn end_leaf(&mut self, cx: <T::Summary as Summary>::Context<'_>) {
+        self.tree.append(
+            SumTree(Arc::new(Node::Leaf {
+                summary: mem::replace(&mut self.leaf_summary, <T::Summary as Summary>::zero(cx)),
+                items: mem::take(&mut self.leaf_items),
+                item_summaries: mem::take(&mut self.leaf_item_summaries),
+            })),
+            cx,
+        );
+    }
+    fn push_item(
+        &mut self,
+        item: &T,
+        summary: &T::Summary,
+        cx: <T::Summary as Summary>::Context<'_>,
+    ) {
+        self.leaf_items.push(item.clone()).unwrap_oob();
+        self.leaf_item_summaries.push(summary.clone()).unwrap_oob();
+        Summary::add_summary(&mut self.leaf_summary, summary, cx);
+    }
+    fn push_tree(
+        &mut self,
+        tree: &SumTree<T>,
+        _: &T::Summary,
+        cx: <T::Summary as Summary>::Context<'_>,
+    ) {
+        self.tree.append(tree.clone(), cx);
+    }
+}
+
+impl<'a, T: Item, D> SeekAggregate<'a, T> for SummarySeekAggregate<D>
+where
+    D: Dimension<'a, T::Summary>,
+{
+    fn begin_leaf(&mut self) {}
+    fn end_leaf(&mut self, _: <T::Summary as Summary>::Context<'_>) {}
+    fn push_item(
+        &mut self,
+        _: &T,
+        summary: &'a T::Summary,
+        cx: <T::Summary as Summary>::Context<'_>,
+    ) {
+        self.0.add_summary(summary, cx);
+    }
+    fn push_tree(
+        &mut self,
+        _: &SumTree<T>,
+        summary: &'a T::Summary,
+        cx: <T::Summary as Summary>::Context<'_>,
+    ) {
+        self.0.add_summary(summary, cx);
+    }
+}
+
+struct End<D>(PhantomData<D>);
+
+impl<D> End<D> {
+    fn new() -> Self {
+        Self(PhantomData)
+    }
+}
+
+impl<'a, S: Summary, D: Dimension<'a, S>> SeekTarget<'a, S, D> for End<D> {
+    fn cmp(&self, _: &D, _: S::Context<'_>) -> Ordering {
+        Ordering::Greater
+    }
+}
+
+impl<D> fmt::Debug for End<D> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_tuple("End").finish()
+    }
+}

crates/sum_tree/src/property_test.rs

@@ -0,0 +1,32 @@
+use core::fmt::Debug;
+
+use proptest::{prelude::*, sample::SizeRange};
+
+use crate::{Item, SumTree, Summary};
+
+impl<T> Arbitrary for SumTree<T>
+where
+    T: Debug + Arbitrary + Item + 'static,
+    T::Summary: Debug + Summary<Context<'static> = ()>,
+{
+    type Parameters = ();
+    type Strategy = BoxedStrategy<Self>;
+
+    fn arbitrary_with((): Self::Parameters) -> Self::Strategy {
+        any::<Vec<T>>()
+            .prop_map(|vec| SumTree::from_iter(vec, ()))
+            .boxed()
+    }
+}
+
+/// A strategy for producing a [`SumTree`] with a given size.
+///
+/// Equivalent to [`proptest::collection::vec`].
+pub fn sum_tree<S, T>(values: S, size: impl Into<SizeRange>) -> impl Strategy<Value = SumTree<T>>
+where
+    T: Debug + Arbitrary + Item + 'static,
+    T::Summary: Debug + Summary<Context<'static> = ()>,
+    S: Strategy<Value = T>,
+{
+    proptest::collection::vec(values, size).prop_map(|vec| SumTree::from_iter(vec, ()))
+}

crates/sum_tree/src/tree_map.rs

@@ -0,0 +1,531 @@
+use std::{cmp::Ordering, fmt::Debug};
+
+use crate::{Bias, ContextLessSummary, Dimension, Edit, Item, KeyedItem, SeekTarget, SumTree};
+
+/// A cheaply-cloneable ordered map based on a [SumTree](crate::SumTree).
+#[derive(Clone, PartialEq, Eq)]
+pub struct TreeMap<K, V>(SumTree<MapEntry<K, V>>)
+where
+    K: Clone + Ord,
+    V: Clone;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct MapEntry<K, V> {
+    key: K,
+    value: V,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct MapKey<K>(Option<K>);
+
+impl<K> Default for MapKey<K> {
+    fn default() -> Self {
+        Self(None)
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct MapKeyRef<'a, K>(Option<&'a K>);
+
+impl<K> Default for MapKeyRef<'_, K> {
+    fn default() -> Self {
+        Self(None)
+    }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct TreeSet<K>(TreeMap<K, ()>)
+where
+    K: Clone + Ord;
+
+impl<K: Clone + Ord, V: Clone> TreeMap<K, V> {
+    pub fn from_ordered_entries(entries: impl IntoIterator<Item = (K, V)>) -> Self {
+        let tree = SumTree::from_iter(
+            entries
+                .into_iter()
+                .map(|(key, value)| MapEntry { key, value }),
+            (),
+        );
+        Self(tree)
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    pub fn contains_key(&self, key: &K) -> bool {
+        self.get(key).is_some()
+    }
+
+    pub fn get(&self, key: &K) -> Option<&V> {
+        let (.., item) = self
+            .0
+            .find::<MapKeyRef<'_, K>, _>((), &MapKeyRef(Some(key)), Bias::Left);
+        if let Some(item) = item {
+            if Some(key) == item.key().0.as_ref() {
+                Some(&item.value)
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    }
+
+    pub fn insert(&mut self, key: K, value: V) {
+        self.0.insert_or_replace(MapEntry { key, value }, ());
+    }
+
+    pub fn insert_or_replace(&mut self, key: K, value: V) -> Option<V> {
+        self.0
+            .insert_or_replace(MapEntry { key, value }, ())
+            .map(|it| it.value)
+    }
+
+    pub fn extend(&mut self, iter: impl IntoIterator<Item = (K, V)>) {
+        let edits: Vec<_> = iter
+            .into_iter()
+            .map(|(key, value)| Edit::Insert(MapEntry { key, value }))
+            .collect();
+        self.0.edit(edits, ());
+    }
+
+    pub fn clear(&mut self) {
+        self.0 = SumTree::default();
+    }
+
+    pub fn remove(&mut self, key: &K) -> Option<V> {
+        let mut removed = None;
+        let mut cursor = self.0.cursor::<MapKeyRef<'_, K>>(());
+        let key = MapKeyRef(Some(key));
+        let mut new_tree = cursor.slice(&key, Bias::Left);
+        if key.cmp(&cursor.end(), ()) == Ordering::Equal {
+            removed = Some(cursor.item().unwrap().value.clone());
+            cursor.next();
+        }
+        new_tree.append(cursor.suffix(), ());
+        drop(cursor);
+        self.0 = new_tree;
+        removed
+    }
+
+    pub fn remove_range(&mut self, start: &impl MapSeekTarget<K>, end: &impl MapSeekTarget<K>) {
+        let start = MapSeekTargetAdaptor(start);
+        let end = MapSeekTargetAdaptor(end);
+        let mut cursor = self.0.cursor::<MapKeyRef<'_, K>>(());
+        let mut new_tree = cursor.slice(&start, Bias::Left);
+        cursor.seek(&end, Bias::Left);
+        new_tree.append(cursor.suffix(), ());
+        drop(cursor);
+        self.0 = new_tree;
+    }
+
+    /// Returns the key-value pair with the greatest key less than or equal to the given key.
+    pub fn closest(&self, key: &K) -> Option<(&K, &V)> {
+        let mut cursor = self.0.cursor::<MapKeyRef<'_, K>>(());
+        let key = MapKeyRef(Some(key));
+        cursor.seek(&key, Bias::Right);
+        cursor.prev();
+        cursor.item().map(|item| (&item.key, &item.value))
+    }
+
+    pub fn iter_from<'a>(&'a self, from: &K) -> impl Iterator<Item = (&'a K, &'a V)> + 'a {
+        let mut cursor = self.0.cursor::<MapKeyRef<'_, K>>(());
+        let from_key = MapKeyRef(Some(from));
+        cursor.seek(&from_key, Bias::Left);
+
+        cursor.map(|map_entry| (&map_entry.key, &map_entry.value))
+    }
+
+    pub fn update<F, T>(&mut self, key: &K, f: F) -> Option<T>
+    where
+        F: FnOnce(&mut V) -> T,
+    {
+        let mut cursor = self.0.cursor::<MapKeyRef<'_, K>>(());
+        let key = MapKeyRef(Some(key));
+        let mut new_tree = cursor.slice(&key, Bias::Left);
+        let mut result = None;
+        if key.cmp(&cursor.end(), ()) == Ordering::Equal {
+            let mut updated = cursor.item().unwrap().clone();
+            result = Some(f(&mut updated.value));
+            new_tree.push(updated, ());
+            cursor.next();
+        }
+        new_tree.append(cursor.suffix(), ());
+        drop(cursor);
+        self.0 = new_tree;
+        result
+    }
+
+    pub fn retain<F: FnMut(&K, &V) -> bool>(&mut self, mut predicate: F) {
+        let mut new_map = SumTree::<MapEntry<K, V>>::default();
+
+        let mut cursor = self.0.cursor::<MapKeyRef<'_, K>>(());
+        cursor.next();
+        while let Some(item) = cursor.item() {
+            if predicate(&item.key, &item.value) {
+                new_map.push(item.clone(), ());
+            }
+            cursor.next();
+        }
+        drop(cursor);
+
+        self.0 = new_map;
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = (&K, &V)> + '_ {
+        self.0.iter().map(|entry| (&entry.key, &entry.value))
+    }
+
+    pub fn values(&self) -> impl Iterator<Item = &V> + '_ {
+        self.0.iter().map(|entry| &entry.value)
+    }
+
+    pub fn first(&self) -> Option<(&K, &V)> {
+        self.0.first().map(|entry| (&entry.key, &entry.value))
+    }
+
+    pub fn last(&self) -> Option<(&K, &V)> {
+        self.0.last().map(|entry| (&entry.key, &entry.value))
+    }
+
+    pub fn insert_tree(&mut self, other: TreeMap<K, V>) {
+        let edits = other
+            .iter()
+            .map(|(key, value)| {
+                Edit::Insert(MapEntry {
+                    key: key.to_owned(),
+                    value: value.to_owned(),
+                })
+            })
+            .collect();
+
+        self.0.edit(edits, ());
+    }
+}
+
+impl<K, V> Debug for TreeMap<K, V>
+where
+    K: Clone + Debug + Ord,
+    V: Clone + Debug,
+{
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_map().entries(self.iter()).finish()
+    }
+}
+
+#[derive(Debug)]
+struct MapSeekTargetAdaptor<'a, T>(&'a T);
+
+impl<'a, K: Clone + Ord, T: MapSeekTarget<K>> SeekTarget<'a, MapKey<K>, MapKeyRef<'a, K>>
+    for MapSeekTargetAdaptor<'_, T>
+{
+    fn cmp(&self, cursor_location: &MapKeyRef<K>, _: ()) -> Ordering {
+        if let Some(key) = &cursor_location.0 {
+            MapSeekTarget::cmp_cursor(self.0, key)
+        } else {
+            Ordering::Greater
+        }
+    }
+}
+
+pub trait MapSeekTarget<K> {
+    fn cmp_cursor(&self, cursor_location: &K) -> Ordering;
+}
+
+impl<K: Ord> MapSeekTarget<K> for K {
+    fn cmp_cursor(&self, cursor_location: &K) -> Ordering {
+        self.cmp(cursor_location)
+    }
+}
+
+impl<K, V> Default for TreeMap<K, V>
+where
+    K: Clone + Ord,
+    V: Clone,
+{
+    fn default() -> Self {
+        Self(Default::default())
+    }
+}
+
+impl<K, V> Item for MapEntry<K, V>
+where
+    K: Clone + Ord,
+    V: Clone,
+{
+    type Summary = MapKey<K>;
+
+    fn summary(&self, _cx: ()) -> Self::Summary {
+        self.key()
+    }
+}
+
+impl<K, V> KeyedItem for MapEntry<K, V>
+where
+    K: Clone + Ord,
+    V: Clone,
+{
+    type Key = MapKey<K>;
+
+    fn key(&self) -> Self::Key {
+        MapKey(Some(self.key.clone()))
+    }
+}
+
+impl<K> ContextLessSummary for MapKey<K>
+where
+    K: Clone,
+{
+    fn zero() -> Self {
+        Default::default()
+    }
+
+    fn add_summary(&mut self, summary: &Self) {
+        *self = summary.clone()
+    }
+}
+
+impl<'a, K> Dimension<'a, MapKey<K>> for MapKeyRef<'a, K>
+where
+    K: Clone + Ord,
+{
+    fn zero(_cx: ()) -> Self {
+        Default::default()
+    }
+
+    fn add_summary(&mut self, summary: &'a MapKey<K>, _: ()) {
+        self.0 = summary.0.as_ref();
+    }
+}
+
+impl<'a, K> SeekTarget<'a, MapKey<K>, MapKeyRef<'a, K>> for MapKeyRef<'_, K>
+where
+    K: Clone + Ord,
+{
+    fn cmp(&self, cursor_location: &MapKeyRef<K>, _: ()) -> Ordering {
+        Ord::cmp(&self.0, &cursor_location.0)
+    }
+}
+
+impl<K> Default for TreeSet<K>
+where
+    K: Clone + Ord,
+{
+    fn default() -> Self {
+        Self(Default::default())
+    }
+}
+
+impl<K> TreeSet<K>
+where
+    K: Clone + Ord,
+{
+    pub fn from_ordered_entries(entries: impl IntoIterator<Item = K>) -> Self {
+        Self(TreeMap::from_ordered_entries(
+            entries.into_iter().map(|key| (key, ())),
+        ))
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    pub fn insert(&mut self, key: K) {
+        self.0.insert(key, ());
+    }
+
+    pub fn remove(&mut self, key: &K) -> bool {
+        self.0.remove(key).is_some()
+    }
+
+    pub fn extend(&mut self, iter: impl IntoIterator<Item = K>) {
+        self.0.extend(iter.into_iter().map(|key| (key, ())));
+    }
+
+    pub fn contains(&self, key: &K) -> bool {
+        self.0.get(key).is_some()
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = &K> + '_ {
+        self.0.iter().map(|(k, _)| k)
+    }
+
+    pub fn iter_from<'a>(&'a self, key: &K) -> impl Iterator<Item = &'a K> + 'a {
+        self.0.iter_from(key).map(move |(k, _)| k)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_basic() {
+        let mut map = TreeMap::default();
+        assert_eq!(map.iter().collect::<Vec<_>>(), vec![]);
+
+        map.insert(3, "c");
+        assert_eq!(map.get(&3), Some(&"c"));
+        assert_eq!(map.iter().collect::<Vec<_>>(), vec![(&3, &"c")]);
+
+        map.insert(1, "a");
+        assert_eq!(map.get(&1), Some(&"a"));
+        assert_eq!(map.iter().collect::<Vec<_>>(), vec![(&1, &"a"), (&3, &"c")]);
+
+        map.insert(2, "b");
+        assert_eq!(map.get(&2), Some(&"b"));
+        assert_eq!(map.get(&1), Some(&"a"));
+        assert_eq!(map.get(&3), Some(&"c"));
+        assert_eq!(
+            map.iter().collect::<Vec<_>>(),
+            vec![(&1, &"a"), (&2, &"b"), (&3, &"c")]
+        );
+
+        assert_eq!(map.closest(&0), None);
+        assert_eq!(map.closest(&1), Some((&1, &"a")));
+        assert_eq!(map.closest(&10), Some((&3, &"c")));
+
+        map.remove(&2);
+        assert_eq!(map.get(&2), None);
+        assert_eq!(map.iter().collect::<Vec<_>>(), vec![(&1, &"a"), (&3, &"c")]);
+
+        assert_eq!(map.closest(&2), Some((&1, &"a")));
+
+        map.remove(&3);
+        assert_eq!(map.get(&3), None);
+        assert_eq!(map.iter().collect::<Vec<_>>(), vec![(&1, &"a")]);
+
+        map.remove(&1);
+        assert_eq!(map.get(&1), None);
+        assert_eq!(map.iter().collect::<Vec<_>>(), vec![]);
+
+        map.insert(4, "d");
+        map.insert(5, "e");
+        map.insert(6, "f");
+        map.retain(|key, _| *key % 2 == 0);
+        assert_eq!(map.iter().collect::<Vec<_>>(), vec![(&4, &"d"), (&6, &"f")]);
+    }
+
+    #[test]
+    fn test_iter_from() {
+        let mut map = TreeMap::default();
+
+        map.insert("a", 1);
+        map.insert("b", 2);
+        map.insert("baa", 3);
+        map.insert("baaab", 4);
+        map.insert("c", 5);
+
+        let result = map
+            .iter_from(&"ba")
+            .take_while(|(key, _)| key.starts_with("ba"))
+            .collect::<Vec<_>>();
+
+        assert_eq!(result.len(), 2);
+        assert!(result.iter().any(|(k, _)| k == &&"baa"));
+        assert!(result.iter().any(|(k, _)| k == &&"baaab"));
+
+        let result = map
+            .iter_from(&"c")
+            .take_while(|(key, _)| key.starts_with("c"))
+            .collect::<Vec<_>>();
+
+        assert_eq!(result.len(), 1);
+        assert!(result.iter().any(|(k, _)| k == &&"c"));
+    }
+
+    #[test]
+    fn test_insert_tree() {
+        let mut map = TreeMap::default();
+        map.insert("a", 1);
+        map.insert("b", 2);
+        map.insert("c", 3);
+
+        let mut other = TreeMap::default();
+        other.insert("a", 2);
+        other.insert("b", 2);
+        other.insert("d", 4);
+
+        map.insert_tree(other);
+
+        assert_eq!(map.iter().count(), 4);
+        assert_eq!(map.get(&"a"), Some(&2));
+        assert_eq!(map.get(&"b"), Some(&2));
+        assert_eq!(map.get(&"c"), Some(&3));
+        assert_eq!(map.get(&"d"), Some(&4));
+    }
+
+    #[test]
+    fn test_extend() {
+        let mut map = TreeMap::default();
+        map.insert("a", 1);
+        map.insert("b", 2);
+        map.insert("c", 3);
+        map.extend([("a", 2), ("b", 2), ("d", 4)]);
+        assert_eq!(map.iter().count(), 4);
+        assert_eq!(map.get(&"a"), Some(&2));
+        assert_eq!(map.get(&"b"), Some(&2));
+        assert_eq!(map.get(&"c"), Some(&3));
+        assert_eq!(map.get(&"d"), Some(&4));
+    }
+
+    #[test]
+    fn test_remove_between_and_path_successor() {
+        use std::path::{Path, PathBuf};
+
+        #[derive(Debug)]
+        pub struct PathDescendants<'a>(&'a Path);
+
+        impl MapSeekTarget<PathBuf> for PathDescendants<'_> {
+            fn cmp_cursor(&self, key: &PathBuf) -> Ordering {
+                if key.starts_with(self.0) {
+                    Ordering::Greater
+                } else {
+                    self.0.cmp(key)
+                }
+            }
+        }
+
+        let mut map = TreeMap::default();
+
+        map.insert(PathBuf::from("a"), 1);
+        map.insert(PathBuf::from("a/a"), 1);
+        map.insert(PathBuf::from("b"), 2);
+        map.insert(PathBuf::from("b/a/a"), 3);
+        map.insert(PathBuf::from("b/a/a/a/b"), 4);
+        map.insert(PathBuf::from("c"), 5);
+        map.insert(PathBuf::from("c/a"), 6);
+
+        map.remove_range(
+            &PathBuf::from("b/a"),
+            &PathDescendants(&PathBuf::from("b/a")),
+        );
+
+        assert_eq!(map.get(&PathBuf::from("a")), Some(&1));
+        assert_eq!(map.get(&PathBuf::from("a/a")), Some(&1));
+        assert_eq!(map.get(&PathBuf::from("b")), Some(&2));
+        assert_eq!(map.get(&PathBuf::from("b/a/a")), None);
+        assert_eq!(map.get(&PathBuf::from("b/a/a/a/b")), None);
+        assert_eq!(map.get(&PathBuf::from("c")), Some(&5));
+        assert_eq!(map.get(&PathBuf::from("c/a")), Some(&6));
+
+        map.remove_range(&PathBuf::from("c"), &PathDescendants(&PathBuf::from("c")));
+
+        assert_eq!(map.get(&PathBuf::from("a")), Some(&1));
+        assert_eq!(map.get(&PathBuf::from("a/a")), Some(&1));
+        assert_eq!(map.get(&PathBuf::from("b")), Some(&2));
+        assert_eq!(map.get(&PathBuf::from("c")), None);
+        assert_eq!(map.get(&PathBuf::from("c/a")), None);
+
+        map.remove_range(&PathBuf::from("a"), &PathDescendants(&PathBuf::from("a")));
+
+        assert_eq!(map.get(&PathBuf::from("a")), None);
+        assert_eq!(map.get(&PathBuf::from("a/a")), None);
+        assert_eq!(map.get(&PathBuf::from("b")), Some(&2));
+
+        map.remove_range(&PathBuf::from("b"), &PathDescendants(&PathBuf::from("b")));
+
+        assert_eq!(map.get(&PathBuf::from("b")), None);
+    }
+}